axe-api 0.19.0 → 0.20.0-rc1

package/src/Server.js

@@ -1,118 +0,0 @@
-import dotenv from "dotenv";
-import express from "express";
-import knex from "knex";
-import { attachPaginate } from "knex-paginate";
-import Config from "./core/Config.js";
-import IoC from "./core/IoC.js";
-import Docs from "./core/Docs.js";
-import Logger from "./core/Logger.js";
-import {
-  getModelInstanceArray,
-  getModelTree,
-  setModelRelations,
-  setModelHooks,
-  setExpressRoutes,
-  detectDbColumns,
-  checkModelColumns,
-} from "./resolvers/index.js";
-
-class Server {
-  constructor(appFolder) {
-    this.app = null;
-    this.appFolder = appFolder;
-    this.models = [];
-    this.modelTree = [];
-  }
-
-  async listen() {
-    await this._bindDependencies();
-    await this._loadConfigurations();
-    await this._loadExpress();
-    await this._analyzeModels();
-    await this._listen();
-  }
-
-  async _bindDependencies() {
-    IoC.singleton("Config", () => new Config());
-    IoC.singleton("Database", async () => {
-      const Config = await IoC.use("Config");
-      const database = knex(Config.Database);
-      attachPaginate();
-      return database;
-    });
-    IoC.singleton("App", async () => {
-      return express();
-    });
-    IoC.singleton("Logger", async () => {
-      const Config = await IoC.use("Config");
-      return new Logger(Config.Application.logLevel);
-    });
-    IoC.singleton("Docs", async () => new Docs());
-    IoC.bind("fs", async () => import("fs"));
-    IoC.bind("path", async () => import("path"));
-    IoC.bind("url", async () => import("url"));
-  }
-
-  async _loadConfigurations() {
-    dotenv.config();
-    const Config = await IoC.use("Config");
-    await Config.load(this.appFolder);
-  }
-
-  async _loadExpress() {
-    this.app = await IoC.use("App");
-    this.app.use(express.urlencoded({ extended: true }));
-    this.app.use(express.json());
-  }
-
-  async _analyzeModels() {
-    this.models = await getModelInstanceArray(this.appFolder);
-    await setModelRelations(this.models);
-    await detectDbColumns(this.models);
-    checkModelColumns(this.models);
-    await setModelHooks("Hooks", this.appFolder, this.models);
-    await setModelHooks("Events", this.appFolder, this.models);
-    this.modelTree = await getModelTree(this.models);
-    await setExpressRoutes(
-      this.app,
-      this.modelTree,
-      this.appFolder,
-      this.models
-    );
-  }
-
-  async _listen() {
-    const Config = await IoC.use("Config");
-
-    this.app.get("/", (req, res) => {
-      res.json({
-        name: "AXE API",
-        description: "The best API creation tool in the world.",
-        aim: "To kill them all!",
-      });
-    });
-
-    if (Config.Application.env === "development") {
-      this.app.get("/docs", async (req, res) => {
-        const docs = await IoC.use("Docs");
-        res.json({
-          routes: docs.get(),
-          modelTree: this.modelTree,
-        });
-      });
-
-      this.app.get("/docs/routes", async (req, res) => {
-        const docs = await IoC.use("Docs");
-        res.json(docs.get().map((route) => `${route.method} ${route.url}`));
-      });
-    }
-
-    this.app.listen(Config.Application.port, () => {
-      console.log(
-        `Example app listening at http://localhost:${Config.Application.port}`
-      );
-    });
-  }
-}
-
-export default Server;

package/src/constants.js

@@ -1,148 +0,0 @@
-const LOG_LEVEL = {
-  NONE: 0,
-  ERROR: 1,
-  WARNING: 2,
-  INFO: 3,
-  ALL: 4,
-};
-
-const HOOK_FUNCTIONS = {
-  onBeforeInsert: "onBeforeInsert",
-  onBeforeUpdateQuery: "onBeforeUpdateQuery",
-  onBeforeUpdate: "onBeforeUpdate",
-  onBeforeDeleteQuery: "onBeforeDeleteQuery",
-  onBeforeDelete: "onBeforeDelete",
-  onBeforePaginate: "onBeforePaginate",
-  onBeforeAll: "onBeforeAll",
-  onBeforeShow: "onBeforeShow",
-  onAfterInsert: "onAfterInsert",
-  onAfterUpdateQuery: "onAfterUpdateQuery",
-  onAfterUpdate: "onAfterUpdate",
-  onAfterDeleteQuery: "onAfterDeleteQuery",
-  onAfterDelete: "onAfterDelete",
-  onAfterPaginate: "onAfterPaginate",
-  onAfterAll: "onAfterAll",
-  onAfterShow: "onAfterShow",
-};
-
-const RELATIONSHIPS = {
-  HAS_ONE: "HAS_ONE",
-  HAS_MANY: "HAS_MANY",
-};
-
-const DEFAULT_METHODS_OF_MODELS = [
-  "constructor",
-  "hasMany",
-  "hasOne",
-  "belongsTo",
-  "serialize",
-  "__defineGetter__",
-  "__defineSetter__",
-  "hasOwnProperty",
-  "__lookupGetter__",
-  "__lookupSetter__",
-  "isPrototypeOf",
-  "propertyIsEnumerable",
-  "toString",
-  "valueOf",
-  "toLocaleString",
-];
-
-const HANDLERS = {
-  INSERT: "store",
-  PAGINATE: "paginate",
-  SHOW: "show",
-  UPDATE: "update",
-  DELETE: "destroy",
-  PATCH: "patch",
-  ALL: "all",
-};
-
-const DEFAULT_HANDLERS = [
-  HANDLERS.INSERT,
-  HANDLERS.PAGINATE,
-  HANDLERS.SHOW,
-  HANDLERS.UPDATE,
-  HANDLERS.PATCH,
-  HANDLERS.DELETE,
-];
-
-const HTTP_METHODS = {
-  POST: "POST",
-  GET: "GET",
-  PUT: "PUT",
-  DELETE: "DELETE",
-  PATCH: "PATCH",
-};
-
-const API_ROUTE_TEMPLATES = {
-  [HANDLERS.INSERT]: {
-    url: (prefix, parentUrl, resource) => `/${prefix}/${parentUrl}${resource}`,
-    method: HTTP_METHODS.POST,
-  },
-  [HANDLERS.PAGINATE]: {
-    url: (prefix, parentUrl, resource) => `/${prefix}/${parentUrl}${resource}`,
-    method: HTTP_METHODS.GET,
-  },
-  [HANDLERS.ALL]: {
-    url: (prefix, parentUrl, resource) =>
-      `/${prefix}/${parentUrl}${resource}/all`,
-    method: HTTP_METHODS.GET,
-  },
-  [HANDLERS.SHOW]: {
-    url: (prefix, parentUrl, resource, primaryKey) =>
-      `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
-    method: HTTP_METHODS.GET,
-  },
-  [HANDLERS.UPDATE]: {
-    url: (prefix, parentUrl, resource, primaryKey) =>
-      `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
-    method: HTTP_METHODS.PUT,
-  },
-  [HANDLERS.PATCH]: {
-    url: (prefix, parentUrl, resource, primaryKey) =>
-      `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
-    method: HTTP_METHODS.PATCH,
-  },
-  [HANDLERS.DELETE]: {
-    url: (prefix, parentUrl, resource, primaryKey) =>
-      `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
-    method: HTTP_METHODS.DELETE,
-  },
-};
-
-const LOG_COLORS = {
-  fgBlack: "\x1b[30m",
-  fgRed: "\x1b[31m",
-  fgGreen: "\x1b[32m",
-  fgYellow: "\x1b[33m",
-  fgBlue: "\x1b[34m",
-  fgMagenta: "\x1b[35m",
-  fgCyan: "\x1b[36m",
-  fgWhite: "\x1b[37m",
-  fgReset: "\x1b[0m",
-};
-
-const DEPENDECY_TYPES = {
-  BIND: "BIND",
-  SINGLETON: "SINGLETON",
-};
-
-const TIMESTAMP_COLUMNS = {
-  CREATED_AT: "createdAtColumn",
-  UPDATED_AT: "updatedAtColumn",
-};
-
-export {
-  LOG_LEVEL,
-  HOOK_FUNCTIONS,
-  RELATIONSHIPS,
-  DEFAULT_METHODS_OF_MODELS,
-  HTTP_METHODS,
-  API_ROUTE_TEMPLATES,
-  LOG_COLORS,
-  DEPENDECY_TYPES,
-  HANDLERS,
-  DEFAULT_HANDLERS,
-  TIMESTAMP_COLUMNS,
-};

package/src/core/Config.js

@@ -1,38 +0,0 @@
-import path from "path";
-import fs from "fs";
-import url from "url";
-
-class Config {
-  constructor() {
-    this._isLoaded = false;
-  }
-
-  async load(directory) {
-    if (this._isLoaded) {
-      return;
-    }
-
-    directory = path.join(directory, "Config");
-    const files = fs.readdirSync(directory);
-    for (const file of files) {
-      const configFile = url.pathToFileURL(path.join(directory, file)).href;
-      let { default: configuration } = await import(configFile);
-
-      if (typeof configuration === "function") {
-        configuration = await configuration();
-      }
-
-      const key = file.replace(".js", "");
-      if (key === "load") {
-        throw new Error(
-          `This is a reserved name. You can not use this name as a configuration file name: "load"`
-        );
-      }
-
-      this[key] = configuration;
-    }
-    this._isLoaded = true;
-  }
-}
-
-export default Config;

package/src/core/Docs.js

@@ -1,43 +0,0 @@
-import { HTTP_METHODS } from "./../constants.js";
-import { getFormValidation } from "./../handlers/helpers.js";
-
-class Docs {
-  constructor() {
-    this.routes = [];
-  }
-
-  push(method, url, model) {
-    let fillable = undefined;
-    let validations = undefined;
-
-    if ([HTTP_METHODS.POST, HTTP_METHODS.PUT].includes(method)) {
-      // Deteching fillable fields
-      if (Array.isArray(model.instance.fillable)) {
-        fillable = model.instance.fillable;
-      } else {
-        fillable = model.instance.fillable[method];
-      }
-
-      // Detecting validations
-      if (model.instance.validations) {
-        validations = getFormValidation(method, model.instance.validations);
-      }
-    }
-
-    this.routes.push({
-      model: model.name,
-      table: model.instance.table,
-      columns: model.instance.columns,
-      method,
-      url,
-      fillable,
-      validations,
-    });
-  }
-
-  get() {
-    return this.routes;
-  }
-}
-
-export default Docs;

package/src/core/HttpResponse.js

@@ -1,10 +0,0 @@
-class HttpResponse extends Error {
-  constructor(status, content) {
-    super(content);
-    this.type = "HttpResponse";
-    this.status = status;
-    this.content = content;
-  }
-}
-
-export default HttpResponse;

package/src/core/IoC.js

@@ -1,41 +0,0 @@
-import { DEPENDECY_TYPES } from "./../constants.js";
-
-const items = {};
-
-const IoC = {
-  bind(name, callback) {
-    this._add(DEPENDECY_TYPES.BIND, name, callback);
-  },
-
-  singleton(name, callback) {
-    this._add(DEPENDECY_TYPES.SINGLETON, name, callback);
-  },
-
-  async use(name) {
-    const item = items[name];
-    if (!item) {
-      throw new Error(`Dependency is not found ${name}`);
-    }
-
-    if (item.type === DEPENDECY_TYPES.BIND) {
-      return await item.callback();
-    }
-
-    if (item.instance) {
-      return item.instance;
-    }
-
-    item.instance = await item.callback();
-    return item.instance;
-  },
-
-  _add(type, name, callback) {
-    items[name] = {
-      type,
-      callback,
-      instance: null,
-    };
-  },
-};
-
-export default IoC;

package/src/core/Logger.js

@@ -1,46 +0,0 @@
-import { LOG_LEVEL, LOG_COLORS } from "./../constants.js";
-const { fgRed, fgGreen, fgYellow, fgCyan, fgReset } = LOG_COLORS;
-
-class Logger {
-  constructor(level) {
-    this.level = level;
-  }
-
-  error(message) {
-    if (this.level <= LOG_LEVEL.ERROR) {
-      console.error(fgRed, "[axe]", message, fgReset);
-    }
-  }
-
-  warn(message) {
-    if (this.level <= LOG_LEVEL.WARNING) {
-      console.warn(fgYellow, "[axe]", message, fgReset);
-    }
-  }
-
-  info(message) {
-    if (this.level <= LOG_LEVEL.INFO) {
-      console.info(fgCyan, "[axe]", message, fgReset);
-    }
-  }
-
-  success(message) {
-    if (this.level <= LOG_LEVEL.INFO) {
-      console.info(fgGreen, "[axe]", message, fgReset);
-    }
-  }
-
-  log(message) {
-    if (this.level === LOG_LEVEL.ALL) {
-      console.log(message);
-    }
-  }
-
-  debug(message) {
-    if (this.level === LOG_LEVEL.ALL) {
-      console.log(message);
-    }
-  }
-}
-
-export default Logger;

package/src/core/Model.js

@@ -1,86 +0,0 @@
-import pluralize from "pluralize";
-import { snakeCase } from "snake-case";
-import { RELATIONSHIPS, DEFAULT_HANDLERS } from "./../constants.js";
-
-class Model {
-  constructor() {
-    this.relations = [];
-  }
-
-  get primaryKey() {
-    return "id";
-  }
-
-  get table() {
-    return pluralize(snakeCase(this.constructor.name));
-  }
-
-  get fillable() {
-    return [];
-  }
-
-  get validations() {
-    return null;
-  }
-
-  get handlers() {
-    return [...DEFAULT_HANDLERS];
-  }
-
-  get middlewares() {
-    return [];
-  }
-
-  get hiddens() {
-    return [];
-  }
-
-  get createdAtColumn() {
-    return "created_at";
-  }
-
-  get updatedAtColumn() {
-    return "updated_at";
-  }
-
-  get transaction() {
-    return null;
-  }
-
-  get ignore() {
-    return false;
-  }
-
-  hasMany(relatedModel, primaryKey = "id", foreignKey = null) {
-    if (!foreignKey) {
-      const currentModelName = pluralize.singular(
-        this.constructor.name.toLowerCase()
-      );
-      foreignKey = `${currentModelName}_id`;
-    }
-    return {
-      type: RELATIONSHIPS.HAS_MANY,
-      model: relatedModel,
-      primaryKey,
-      foreignKey,
-    };
-  }
-
-  hasOne(relatedModel, primaryKey = "id", foreignKey = null) {
-    if (!foreignKey) {
-      foreignKey = `${pluralize.singular(relatedModel.toLowerCase())}_id`;
-    }
-    return {
-      type: RELATIONSHIPS.HAS_ONE,
-      model: relatedModel,
-      primaryKey,
-      foreignKey,
-    };
-  }
-
-  belongsTo(relatedModel, primaryKey, foreignKey) {
-    return this.hasOne(relatedModel, foreignKey, primaryKey);
-  }
-}
-
-export default Model;