JSPM

backend-js

1.5.7
  • ESM via JSPM
  • ES Module Entrypoint
  • Export Map
  • Keywords
  • License
  • Repository URL
  • TypeScript Types
  • README
  • Created
  • Published
  • Downloads 15
  • Score
    100M100P100Q49681F
  • License MIT

Backend-js is a layer built above expressjs to enable behaviours framework for nodejs applications.

Package Exports

  • backend-js
  • backend-js/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (backend-js) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

backend-js Codacy Badge

0_00

Backend-js is a layer built above expressjs and socket.io to enable the Behaviours Framework for Node.js applications.

📦 Installation

npm install backend-js

🚀 Usage

🔧 Backend Initialization

var backend = require('backend-js');
var App = backend.app(__dirname + '/behaviours', {
    path: '/api/v1',
    parser: 'json',
    port: 8383,
    origins: '*'
});

var App = app(path, options)

Parameter Type Description
path string Path to the behaviours directory.
options object App configuration options.
options.path string Prefix path appended to the beginning of routes.
options.parser string Supports json, text, raw, or urlencoded. Parses request/response body accordingly.
options.parserOptions object Options for body-parser.
options.port number Port of the server.
options.origins string Allowed AJAX origins (comma-separated or "*" for all).
options.static object Options for serving static files.
options.static.route string Virtual route for static content.
options.static.path string Path to directory containing static files.
Returns Type Description
App function Express app instance (API reference).

🧩 Model Definition

var backend = require('backend-js');
var model = backend.model();
var User = model({
  name: 'User'
}, {
  username: String,
  password: String
});

var ModelEntity = model(options, attributes, plugins)

Parameter Type Description
options string | object Model name or full configuration object.
options.name string Name of the model.
options.features object Custom model features passed to the data access layer.
options.query array Default query represented by QueryExpression.
attributes object Schema attributes (String, Number, Date). Supports nested objects or arrays.
plugins array Array of mongoose plugins.
Returns Type Description
ModelEntity function Constructor for the defined model entity.

🔍 Query Builder

var QueryExpression = backend.QueryExpression;
var ComparisonOperators = {
    EQUAL: '=',
    NE: '$ne'
};
var LogicalOperators = {
    AND: '$and',
    OR: '$or',
    NOT: '$not'
};
backend.setComparisonOperators(ComparisonOperators);
backend.setLogicalOperators(LogicalOperators);

var query = [
  new QueryExpression({
    fieldName: 'username',
    comparisonOperator: ComparisonOperators.EQUAL,
    fieldValue: 'name'
  }),
  new QueryExpression({
    fieldName: 'password',
    comparisonOperator: ComparisonOperators.EQUAL,
    fieldValue: 'pass',
    logicalOperator: LogicalOperators.AND,
    contextualLevel: 0
  })
];

setComparisonOperators(operators) / setLogicalOperators(operators)

Parameter Type Description
operators object Key-value pairs mapping to database engine operators (used by data access).

var expression = new QueryExpression(options)

Parameter Type Description
options.fieldName string Field name in the model.
options.comparisonOperator string Comparison operator (=, $ne, etc.).
options.fieldValue any Value to compare against the field.
options.logicalOperator string Logical operator ($and, $or, $not).
options.contextualLevel number Nesting level of conditions (for grouping).
Returns Type Description
expression object Query expression object used in queries.

🧱 Entity API

var ModelEntity = backend.ModelEntity;
var entity = new ModelEntity({});
var model = entity.getObjectConstructor();
var schema = entity.getObjectAttributes();
var features = entity.getObjectFeatures();
var query = entity.getObjectQuery();

var entity = new ModelEntity(features)

Parameter Type Description
features object Special model functionalities passed to the data access layer.
Returns Type Description
entity object Holds model metadata and schema.

Entity Methods:

  • getObjectConstructor() – returns model constructor
  • getObjectAttributes() – returns schema fields
  • getObjectFeatures() – returns model features
  • getObjectQuery() – returns default query array

⚙️ Behaviour (API Unit)

var getUsers = behaviour({
  name: 'GetUsers',
  version: '1',
  path: '/users',
  method: 'GET'
}, function(init) {
  return function() {
    var self = init.apply(this, arguments).self();
    self.begin('Query', function(key, businessController, operation) {
        operation
          .entity(new User())
          .append(true)
          .apply();
    });
  };
});

var Behavior = behaviour(option, constructor)

Parameter Type Description
option object API metadata (name, version, path, method, params, returns).
constructor function Business logic with database or response mapping functionality.

🧬 Data Access

Define your own data access layer like below:

var backend = require('backend-js');

var ModelController = function () {
    self.removeObjects = function (queryExprs, entity, callback) {
        // do remove
    };
    self.addObjects = function (objsAttributes, entity, callback) {
        // do add new
    };
    self.getObjects = function (queryExprs, entity, callback) {
        // do select
    };
    self.save = function (callback, oldSession) {
        // do save
    };
};

ModelController.defineEntity = function (name, attributes) {
    // define entity
    return entity;
};

ModelController.prototype.constructor = ModelController;

backend.setModelController(new ModelController());

🚀 Starter Project

Explore the official starter to learn Backend-JS with examples:

🔗 https://github.com/QuaNode/BeamJS-Start

📄 License