axe-api 0.19.0 → 0.20.0-rc1

package/src/handlers/update.js

@@ -1,92 +0,0 @@
-import {
-  getFormData,
-  getFormValidation,
-  callHooks,
-  filterHiddenFields,
-  bindTimestampValues,
-  serializeData,
-  addForeignKeyQuery,
-} from "./helpers.js";
-import Validator from "validatorjs";
-import { HOOK_FUNCTIONS, TIMESTAMP_COLUMNS, HANDLERS } from "./../constants.js";
-import HttpResponse from "./../core/HttpResponse.js";
-
-export default async (context) => {
-  const { request, response, model, trx, relation, parentModel } = context;
-
-  const query = trx.from(model.instance.table);
-
-  // If there is a relation, we should bind it
-  addForeignKeyQuery(request, query, relation, parentModel);
-
-  await callHooks(model, HOOK_FUNCTIONS.onBeforeUpdateQuery, {
-    ...context,
-    query,
-  });
-
-  let item = await query
-    .where(model.instance.primaryKey, request.params[model.instance.primaryKey])
-    .first();
-  if (!item) {
-    throw new HttpResponse(404, {
-      message: `The item is not found on ${model.name}.`,
-    });
-  }
-
-  await callHooks(model, HOOK_FUNCTIONS.onAfterUpdateQuery, {
-    ...context,
-    item,
-    query,
-  });
-
-  const formData = getFormData(request, model.instance.fillable);
-
-  const formValidationRules = getFormValidation(
-    request.method,
-    model.instance.validations
-  );
-
-  if (formValidationRules) {
-    const validation = new Validator(formData, formValidationRules);
-    if (validation.fails()) {
-      return response.status(400).json(validation.errors);
-    }
-  }
-
-  // We should bind the timestamp values
-  bindTimestampValues(formData, [TIMESTAMP_COLUMNS.UPDATED_AT], model);
-
-  await callHooks(model, HOOK_FUNCTIONS.onBeforeUpdate, {
-    ...context,
-    item,
-    formData,
-    query,
-  });
-
-  await query
-    .where(model.instance.primaryKey, item[model.instance.primaryKey])
-    .update(formData);
-  item = await trx(model.instance.table)
-    .where(model.instance.primaryKey, item[model.instance.primaryKey])
-    .first();
-
-  await callHooks(model, HOOK_FUNCTIONS.onAfterUpdate, {
-    ...context,
-    item,
-    formData,
-    query,
-  });
-
-  // Serializing the data by the model's serialize method
-  item = await serializeData(
-    item,
-    model.instance.serialize,
-    HANDLERS.UPDATE,
-    request
-  );
-
-  // Filtering hidden fields from the response data.
-  filterHiddenFields([item], model.instance.hiddens);
-
-  return response.json(item);
-};

package/src/resolvers/checkModelColumns.js

@@ -1,113 +0,0 @@
-import { RELATIONSHIPS } from "./../constants.js";
-
-const getModelFillableColumns = (model) => {
-  if (!model.instance.fillable) {
-    return [];
-  }
-
-  if (!model.instance.fillable.POST && !model.instance.fillable.PUT) {
-    return model.instance.fillable;
-  }
-
-  return [...model.instance.fillable.POST, ...model.instance.fillable.PUT];
-};
-
-const getModelHiddenColumns = (model) => {
-  if (!model.instance.hiddens) {
-    return [];
-  }
-
-  return model.instance.hiddens;
-};
-
-const getModelFormValidationColumns = (model) => {
-  if (!model.instance.validations) {
-    return [];
-  }
-
-  if (!model.instance.validations.POST && !model.instance.validations.PUT) {
-    return Object.keys(model.instance.validations);
-  }
-
-  return [
-    ...Object.keys(
-      model.instance.validations.POST ? model.instance.validations.POST : {}
-    ),
-    ...Object.keys(
-      model.instance.validations.PUT ? model.instance.validations.PUT : {}
-    ),
-  ];
-};
-
-const getTimestampsColumns = (model) => {
-  const columns = [];
-
-  if (model.instance.createdAtColumn) {
-    columns.push(model.instance.createdAtColumn);
-  }
-
-  if (model.instance.updatedAtColumn) {
-    columns.push(model.instance.updatedAtColumn);
-  }
-
-  return columns;
-};
-
-const checkModelColumnsOrFail = (model, modelColumns) => {
-  const undefinedColumns = modelColumns.filter(
-    (modelColumn) => !model.instance.columnNames.includes(modelColumn)
-  );
-  if (undefinedColumns.length > 0) {
-    throw new Error(
-      `${
-        model.name
-      } model doesn't have the following columns on the database; "${
-        model.instance.table
-      }.${undefinedColumns.join(",")}"`
-    );
-  }
-};
-
-const checkHasManyRelation = (models, model, relation) => {
-  checkModelColumnsOrFail(model, [relation.primaryKey]);
-  const relatedModel = models.find((item) => item.name === relation.model);
-  if (!relatedModel) {
-    throw new Error(`Undefined related model: ${relation.model}`);
-  }
-  checkModelColumnsOrFail(relatedModel, [relation.foreignKey]);
-};
-
-const checkHasOneRelation = (models, model, relation) => {
-  checkModelColumnsOrFail(model, [relation.foreignKey]);
-  const relatedModel = models.find((item) => item.name === relation.model);
-  if (!relatedModel) {
-    throw new Error(`Undefined related model: ${relation.model}`);
-  }
-  checkModelColumnsOrFail(relatedModel, [relation.primaryKey]);
-};
-
-const checkerByRelationTypes = {
-  [RELATIONSHIPS.HAS_MANY]: checkHasManyRelation,
-  [RELATIONSHIPS.HAS_ONE]: checkHasOneRelation,
-};
-
-const checkRelationColumnsOrFail = (models, model) => {
-  for (const relation of model.instance.relations) {
-    const checker = checkerByRelationTypes[relation.type];
-    if (!checker) {
-      throw new Error(`Undefined relation type: ${relation.type}`);
-    }
-    checker(models, model, relation);
-  }
-};
-
-export default (models) => {
-  models.forEach((model) => {
-    checkModelColumnsOrFail(model, getModelFillableColumns(model));
-    checkModelColumnsOrFail(model, getModelFormValidationColumns(model));
-    checkModelColumnsOrFail(model, getModelHiddenColumns(model));
-    checkModelColumnsOrFail(model, getTimestampsColumns(model));
-    checkModelColumnsOrFail(model, [model.instance.primaryKey]);
-    checkRelationColumnsOrFail(models, model);
-  });
-};

package/src/resolvers/detectDbColumns.js

@@ -1,42 +0,0 @@
-import schemaInspector from "knex-schema-inspector";
-import IoC from "./../core/IoC.js";
-
-const getDatabaseColumns = async () => {
-  const database = await IoC.use("Database");
-  const inspector = schemaInspector.default(database);
-  const databaseColumns = [];
-  for (const table of await inspector.tables()) {
-    const columns = await inspector.columnInfo(table);
-    databaseColumns.push(
-      ...columns.map((column) => {
-        return {
-          ...column,
-          table_name: table,
-        };
-      })
-    );
-  }
-
-  return databaseColumns;
-};
-
-const bindModelColumns = (models, columns) => {
-  for (const model of models) {
-    model.instance.columns = columns.filter(
-      (column) => column.table_name === model.instance.table
-    );
-
-    if (model.instance.columns.length === 0) {
-      throw new Error(
-        `The "${model.instance.table}" table doesn't have any column. Are you sure about the table name?`
-      );
-    }
-
-    model.instance.columnNames = model.instance.columns.map((i) => i.name);
-  }
-};
-
-export default async (models) => {
-  const columns = await getDatabaseColumns();
-  bindModelColumns(models, columns);
-};

package/src/resolvers/getModelInstanceArray.js

@@ -1,27 +0,0 @@
-import IoC from "./../core/IoC.js";
-
-export default async (appDirectory) => {
-  const logger = await IoC.use("Logger");
-  const fs = await IoC.use("fs");
-  const path = await IoC.use("path");
-  const url = await IoC.use("url");
-
-  appDirectory = path.join(appDirectory, "Models");
-  const models = [];
-  const files = fs
-    .readdirSync(appDirectory)
-    .filter((file) => file.split(".").pop() === "js");
-
-  for (const file of files) {
-    const modelName = file.replace(".js", "");
-    const modelFile = url.pathToFileURL(path.join(appDirectory, file)).href;
-    const { default: Model } = await import(modelFile);
-    models.push({
-      name: modelName,
-      instance: new Model(),
-    });
-  }
-
-  logger.info("Models have been resolved!");
-  return models;
-};

package/src/resolvers/getModelTree.js

@@ -1,63 +0,0 @@
-import IoC from "./../core/IoC.js";
-import { RELATIONSHIPS } from "./../constants.js";
-
-const getChildModelNames = (model) => {
-  return model.instance.relations
-    .filter((item) => item.type === RELATIONSHIPS.HAS_MANY)
-    .map((item) => item.model);
-};
-
-const _setChildrens = (model, models) => {
-  const childModelNames = getChildModelNames(model);
-  model.children = models.filter((item) => childModelNames.includes(item.name));
-  for (const child of model.children) {
-    _setChildrens(child, models);
-  }
-};
-
-const getRootLevelOfTree = (models) => {
-  const childModels = [];
-  models.forEach((model) => {
-    childModels.push(
-      ...model.instance.relations
-        .filter((relation) => relation.type === RELATIONSHIPS.HAS_MANY)
-        .map((relation) => relation.model)
-    );
-  });
-
-  return models.filter((model) => !childModels.includes(model.name));
-};
-
-const createRecursiveTree = (tree, models) => {
-  for (const model of tree) {
-    _setChildrens(model, models);
-  }
-};
-
-const addNestedRoutes = (tree, models) => {
-  // We should add recursive models
-  models.forEach((model) => {
-    const recursiveRelations = model.instance.relations.filter(
-      (relation) => relation.model === model.name
-    );
-
-    if (recursiveRelations.length === 2) {
-      tree.push({
-        isRecursive: true,
-        children: [],
-        ...model,
-      });
-    }
-  });
-};
-
-export default async (models) => {
-  const logger = await IoC.use("Logger");
-
-  const tree = getRootLevelOfTree(models);
-  createRecursiveTree(tree, models);
-  addNestedRoutes(tree, models);
-
-  logger.info("Model tree map has been created.");
-  return tree;
-};

package/src/resolvers/index.js

@@ -1,17 +0,0 @@
-import getModelInstanceArray from "./getModelInstanceArray.js";
-import getModelTree from "./getModelTree.js";
-import setModelRelations from "./setModelRelations.js";
-import setModelHooks from "./setModelHooks.js";
-import setExpressRoutes from "./setExpressRoutes.js";
-import detectDbColumns from "./detectDbColumns.js";
-import checkModelColumns from "./checkModelColumns.js";
-
-export {
-  getModelInstanceArray,
-  getModelTree,
-  setModelRelations,
-  setModelHooks,
-  setExpressRoutes,
-  detectDbColumns,
-  checkModelColumns,
-};

package/src/resolvers/setExpressRoutes.js

@@ -1,279 +0,0 @@
-import IoC from "./../core/IoC.js";
-import pluralize from "pluralize";
-import { paramCase, camelCase } from "change-case";
-import { RELATIONSHIPS, API_ROUTE_TEMPLATES } from "./../constants.js";
-import Handlers from "./../handlers/index.js";
-
-let Config = null;
-
-const setTransactionOption = (option, handler, defaultValue) => {
-  if (Array.isArray(option)) {
-    if (option.some((i) => i.handler === handler)) {
-      defaultValue = option.find((i) => i.handler === handler).transaction;
-    }
-  } else {
-    defaultValue = option;
-  }
-
-  return defaultValue;
-};
-
-const hasTransaction = (config, model, handler) => {
-  const global = config.Application.transaction;
-  const local = model.instance.transaction;
-  let privilegedOption = false;
-
-  if (global) {
-    privilegedOption = setTransactionOption(global, handler, privilegedOption);
-  }
-
-  if (local !== null) {
-    privilegedOption = setTransactionOption(local, handler, privilegedOption);
-  }
-
-  return privilegedOption;
-};
-
-const requestHandler = async (handler, req, res, next, context) => {
-  try {
-    context.trx = context.database;
-    if (hasTransaction(Config, context.model, handler)) {
-      context.trx = await context.database.transaction();
-    }
-    await Handlers[handler]({
-      ...context,
-      request: req,
-      response: res,
-    });
-
-    if (context.trx.commit) {
-      await context.trx.commit();
-    }
-  } catch (error) {
-    if (context.trx.rollback) {
-      await context.trx.rollback();
-    }
-
-    if (error.type === "HttpResponse") {
-      return res.status(error.status).json(error.content);
-    }
-
-    next(error);
-  }
-};
-
-const ucFirst = (string) => {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-};
-
-const getResourcePath = (model, relation) => {
-  return relation
-    ? relation.resource
-    : paramCase(pluralize.plural(model.name)).toLowerCase();
-};
-
-const getPrimaryKeyName = (model) => {
-  return (
-    pluralize.singular(model.name).toLowerCase() +
-    ucFirst(model.instance.primaryKey)
-  );
-};
-
-const createChildRoutes = async (model, models, resource, urlPrefix) => {
-  if (model.children.length === 0) {
-    return;
-  }
-
-  // We should different parameter name for child routes
-  const primaryKey = getPrimaryKeyName(model);
-  const subRelations = model.instance.relations.filter(
-    (item) => item.type === RELATIONSHIPS.HAS_MANY
-  );
-  for (const relation of subRelations) {
-    const child = model.children.find((item) => item.name === relation.model);
-    // It should be recursive
-    await createRouteByModel(
-      child,
-      models,
-      `${urlPrefix}${resource}/:${primaryKey}/`,
-      model,
-      relation
-    );
-  }
-};
-
-const createNestedRoutes = async (
-  model,
-  models,
-  allowRecursive,
-  urlPrefix,
-  resource
-) => {
-  if (!model.isRecursive || !allowRecursive) {
-    return;
-  }
-
-  // We should different parameter name for child routes
-  const relation = model.instance.relations.find(
-    (relation) =>
-      relation.model === model.name && relation.type === RELATIONSHIPS.HAS_MANY
-  );
-
-  await createRouteByModel(
-    model,
-    models,
-    `${urlPrefix}${resource}/:${camelCase(relation.foreignKey)}/`,
-    model,
-    relation,
-    false
-  );
-};
-
-const hasAMiddleware = (definition, handler) => {
-  if (typeof definition === "function") {
-    return true;
-  }
-
-  if (definition.handler === handler) {
-    return true;
-  }
-
-  if (
-    Array.isArray(definition.handler) &&
-    definition.handler.includes(handler)
-  ) {
-    return true;
-  }
-
-  return false;
-};
-
-const getModelMiddlewares = (model, handler) => {
-  const middlewares = [];
-  if (model.instance.middlewares.length > 0) {
-    const filtered = model.instance.middlewares
-      .filter((definition) => hasAMiddleware(definition, handler))
-      .map((definition) => {
-        if (typeof definition === "function") {
-          return definition;
-        }
-        return definition.middleware;
-      });
-    middlewares.push(...filtered);
-  }
-  return middlewares;
-};
-
-const getRootPrefix = () => {
-  if (Config.Application.prefix) {
-    // NOSONAR
-    return Config.Application.prefix.replace(/^\/|\/$/g, "");
-  }
-  return "api";
-};
-
-const createRouteByModel = async (
-  model,
-  models,
-  urlPrefix = "",
-  parentModel = null,
-  relation = null,
-  allowRecursive = true
-) => {
-  if (model.instance.ignore) {
-    return;
-  }
-
-  const logger = await IoC.use("Logger");
-  const app = await IoC.use("App");
-  const database = await IoC.use("Database");
-  const docs = await IoC.use("Docs");
-
-  const context = {
-    model,
-    models,
-    parentModel,
-    relation,
-    Config,
-    database,
-    logger,
-  };
-
-  const resource = getResourcePath(model, relation);
-
-  // We create and handle routes by not duplicate so many lines.
-  for (const handler of Object.keys(API_ROUTE_TEMPLATES)) {
-    if (!model.instance.handlers.includes(handler)) {
-      continue;
-    }
-
-    const routeTemplate = API_ROUTE_TEMPLATES[handler];
-    const url = routeTemplate.url(
-      getRootPrefix(),
-      urlPrefix,
-      resource,
-      model.instance.primaryKey
-    );
-    logger.debug(`Model routes created: ${url}`);
-
-    // Detecting filters
-    const middlewares = getModelMiddlewares(model, handler);
-
-    // Adding created route to the documentation
-    docs.push(routeTemplate.method, url, model);
-
-    // Adding the route to the express
-    app[routeTemplate.method.toLowerCase()](
-      url,
-      middlewares,
-      (req, res, next) => {
-        requestHandler(handler, req, res, next, context);
-      }
-    );
-  }
-
-  await createChildRoutes(model, models, resource, urlPrefix);
-  await createNestedRoutes(model, models, allowRecursive, urlPrefix, resource);
-};
-
-const getGeneralHooks = async (appDirectory) => {
-  const fs = await IoC.use("fs");
-  const path = await IoC.use("path");
-  const url = await IoC.use("url");
-
-  // Calling the user's custom definitions
-  const customInitFile = path.join(appDirectory, `init.js`);
-  if (fs.existsSync(customInitFile)) {
-    const { onBeforeInit, onAfterInit } = await import(
-      url.pathToFileURL(customInitFile).href
-    );
-    return { onBeforeInit, onAfterInit };
-  }
-
-  return { onBeforeInit: null, onAfterInit: null };
-};
-
-const createRoutesByModelTree = async (modelTree, models) => {
-  for (const model of modelTree) {
-    await createRouteByModel(model, models);
-  }
-};
-
-export default async (app, modelTree, appDirectory, models) => {
-  Config = await IoC.use("Config");
-  const logger = await IoC.use("Logger");
-
-  const { onBeforeInit, onAfterInit } = await getGeneralHooks(appDirectory);
-
-  if (typeof onBeforeInit === "function") {
-    await onBeforeInit({ app });
-  }
-
-  await createRoutesByModelTree(modelTree, models);
-
-  if (typeof onAfterInit === "function") {
-    await onAfterInit({ app });
-  }
-
-  logger.info("All routes have been created.");
-};

package/src/resolvers/setModelHooks.js

@@ -1,25 +0,0 @@
-import IoC from "./../core/IoC.js";
-import { HOOK_FUNCTIONS } from "./../constants.js";
-
-export default async (type, appDirectory, models) => {
-  const logger = await IoC.use("Logger");
-  const fs = await IoC.use("fs");
-  const path = await IoC.use("path");
-  const url = await IoC.use("url");
-
-  appDirectory = path.join(appDirectory, type);
-  for (const model of models) {
-    model[type.toLowerCase()] = {};
-    const fileName = path.join(appDirectory, `${model.name}${type}.js`);
-    if (fs.existsSync(fileName)) {
-      const Hooks = await import(url.pathToFileURL(fileName).href);
-      for (const hook of Object.keys(HOOK_FUNCTIONS)) {
-        if (Hooks[hook]) {
-          model[type.toLowerCase()][hook] = Hooks[hook];
-        }
-      }
-    }
-  }
-
-  logger.info(`${type} have been mapped.`);
-};

package/src/resolvers/setModelRelations.js

@@ -1,41 +0,0 @@
-import IoC from "./../core/IoC.js";
-import { DEFAULT_METHODS_OF_MODELS } from "./../constants.js";
-import { paramCase } from "change-case";
-
-const getInstanceMethods = (obj) => {
-  let properties = new Set();
-  let currentObj = obj;
-  do {
-    Object.getOwnPropertyNames(currentObj).forEach((item) =>
-      properties.add(item)
-    );
-  } while ((currentObj = Object.getPrototypeOf(currentObj)));
-  return [...properties.keys()].filter(
-    (item) => typeof obj[item] === "function"
-  );
-};
-
-const getModelRelationMethods = (model) => {
-  return getInstanceMethods(model.instance).filter(
-    (method) => !DEFAULT_METHODS_OF_MODELS.includes(method)
-  );
-};
-
-export default async (models) => {
-  const logger = await IoC.use("Logger");
-
-  for (const model of models) {
-    const relationMethods = getModelRelationMethods(model);
-
-    for (const relationMethod of relationMethods) {
-      const relation = model.instance[relationMethod]();
-      model.instance.relations.push({
-        name: relationMethod,
-        resource: paramCase(relationMethod).toLowerCase(),
-        ...relation,
-      });
-    }
-  }
-
-  logger.info("All relationships have been resolved.");
-};