@quatrain/core 1.0.0-beta2 → 1.0.0-beta20

package/lib/Auth.d.ts

@@ -0,0 +1,25 @@
+import Middleware from './authentication/middlewares/AuthMiddleware';
+export declare enum AuthAction {
+    SIGNIN = "signin",
+    SIGNUP = "signup",
+    SIGNOUT = "signout"
+}
+/**
+ * Authentication Parameters acceptable keys
+ */
+export type AuthParametersKeys = 'host' | 'alias' | 'mapping' | 'middlewares' | 'config' | 'fixtures' | 'debug';
+/**
+ * Backend parameters interface
+ */
+export interface AuthParameters {
+    host?: string;
+    alias?: string;
+    mapping?: {
+        [x: string]: any;
+    };
+    middlewares?: Middleware[];
+    config?: any;
+    fixtures?: any;
+    softDelete?: boolean;
+    debug?: boolean;
+}

package/lib/Auth.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthAction = void 0;
+var AuthAction;
+(function (AuthAction) {
+    AuthAction["SIGNIN"] = "signin";
+    AuthAction["SIGNUP"] = "signup";
+    AuthAction["SIGNOUT"] = "signout";
+})(AuthAction || (exports.AuthAction = AuthAction = {}));

package/lib/Backend.d.ts

@@ -1,9 +1,10 @@
-import Middleware from "./backends/middlewares/Middleware";
+import Middleware from './backends/middlewares/Middleware';
 export declare enum BackendAction {
     CREATE = "create",
     READ = "read",
     UPDATE = "update",
-    DELETE = "delete"
+    DELETE = "delete",
+    WRITE = "write"
 }
 /**
  * Default interface for a backend record
@@ -23,6 +24,9 @@ export type BackendParametersKeys = 'host' | 'alias' | 'mapping' | 'middlewares'
 export interface BackendParameters {
     host?: string;
     alias?: string;
+    hierarchy?: {
+        [collection: string]: any;
+    };
     mapping?: {
         [x: string]: any;
     };
@@ -30,5 +34,6 @@ export interface BackendParameters {
     config?: any;
     fixtures?: any;
     softDelete?: boolean;
+    useNativeForeignKeys?: boolean;
     debug?: boolean;
 }

package/lib/Backend.js

@@ -7,4 +7,5 @@ var BackendAction;
     BackendAction["READ"] = "read";
     BackendAction["UPDATE"] = "update";
     BackendAction["DELETE"] = "delete";
+    BackendAction["WRITE"] = "write";
 })(BackendAction || (exports.BackendAction = BackendAction = {}));

package/lib/Core.d.ts

@@ -1,26 +1,37 @@
+import { AbstractAuthAdapter } from './authentication';
 import { AbstractAdapter } from './backends/AbstractAdapter';
-import { UserCore } from './components/User';
+import { User } from './components/User';
 import { DataObjectClass } from './components/types/DataObjectClass';
 export type BackendRegistry<T extends AbstractAdapter> = {
     [x: string]: T;
 };
+export interface AuthAdapter extends AbstractAuthAdapter {
+}
 export declare class Core {
+    static storagePrefix: string;
     static defaultBackend: string;
-    static userClass: typeof UserCore;
+    static defaultStorage: string;
+    static userClass: typeof User;
     static classRegistry: {
         [key: string]: any;
     };
     static logger: Console;
+    static auth: AuthAdapter | AbstractAuthAdapter;
     static timestamp: () => string;
     protected static _backends: BackendRegistry<any>;
+    protected static _storages: BackendRegistry<any>;
     static definition(key: string): {
         manifest: {
             type: StringConstructor;
             mandatory: boolean;
         };
     };
+    static addConfig(key: string, value: any): Promise<void>;
+    static getConfig(key: string): Promise<any>;
     static addBackend(backend: AbstractAdapter, alias: string, setDefault?: boolean): void;
     static getBackend<T extends AbstractAdapter>(alias?: string): T;
+    static addStorage(backend: AbstractAdapter, alias: string, setDefault?: boolean): void;
+    static getStorage<T extends AbstractAdapter>(alias?: string): T;
     static addClass(name: string, obj: any): void;
     static getClass(name: string): any;
     /**

package/lib/Core.js

@@ -1,8 +1,19 @@
 "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 });
 exports.Core = void 0;
 const DataObject_1 = require("./components/DataObject");
 const User_1 = require("./components/User");
+const storage = require('node-persist');
+storage.init( /* options ... */);
 class Core {
     static definition(key) {
         return {
@@ -12,6 +23,16 @@ class Core {
             },
         };
     }
+    static addConfig(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield storage.set(`${this.storagePrefix}_${key}`, value);
+        });
+    }
+    static getConfig(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield storage.get(`${this.storagePrefix}_${key}`);
+        });
+    }
     static addBackend(backend, alias, setDefault = false) {
         Core._backends[alias] = backend;
         if (setDefault) {
@@ -26,6 +47,20 @@ class Core {
             throw new Error(`Unknown backend alias: '${alias}'`);
         }
     }
+    static addStorage(backend, alias, setDefault = false) {
+        Core._storages[alias] = backend;
+        if (setDefault) {
+            Core.defaultStorage = alias;
+        }
+    }
+    static getStorage(alias = this.defaultStorage) {
+        if (this._storages[alias]) {
+            return this._storages[alias];
+        }
+        else {
+            throw new Error(`Unknown storage alias: '${alias}'`);
+        }
+    }
     static addClass(name, obj) {
         Core.classRegistry[name] = obj;
     }
@@ -51,10 +86,13 @@ class Core {
     }
 }
 exports.Core = Core;
+Core.storagePrefix = 'core';
 Core.defaultBackend = '@default';
-Core.userClass = User_1.UserCore;
+Core.defaultStorage = '@default';
+Core.userClass = User_1.User;
 Core.classRegistry = {};
 Core.logger = console;
 // How timestamp are formatted
 Core.timestamp = () => new Date().toISOString();
 Core._backends = {};
+Core._storages = {};

package/lib/authentication/AbstractAuthAdapter.d.ts

@@ -0,0 +1,18 @@
+import { AuthParameters, AuthParametersKeys } from '../Auth';
+import { User } from '../components/User';
+import { AuthInterface } from './types/AuthInterface';
+export declare abstract class AbstractAuthAdapter implements AuthInterface {
+    protected _alias: string;
+    protected _params: AuthParameters;
+    constructor(params?: AuthParameters);
+    setParam(key: AuthParametersKeys, value: any): void;
+    getParam(key: AuthParametersKeys): any;
+    set alias(alias: string);
+    get alias(): string;
+    abstract register(user: User): Promise<any>;
+    abstract signup(login: string, password: string): Promise<any>;
+    abstract signout(user: User): Promise<any>;
+    abstract update(user: User, updatable: any): Promise<any>;
+    abstract delete(user: User): Promise<any>;
+    abstract getAuthToken(token: string): any;
+}

package/lib/authentication/AbstractAuthAdapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractAuthAdapter = void 0;
+class AbstractAuthAdapter {
+    constructor(params = {}) {
+        this._alias = '';
+        this._params = {};
+        this._alias = params.alias || '';
+    }
+    setParam(key, value) {
+        this._params[key] = value;
+    }
+    getParam(key) {
+        return this._params[key];
+    }
+    set alias(alias) {
+        this._alias = alias;
+    }
+    get alias() {
+        return this._alias;
+    }
+}
+exports.AbstractAuthAdapter = AbstractAuthAdapter;

package/lib/authentication/AuthenticationError.d.ts

@@ -0,0 +1,2 @@
+export declare class AuthenticationError extends Error {
+}

package/lib/authentication/AuthenticationError.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationError = void 0;
+class AuthenticationError extends Error {
+}
+exports.AuthenticationError = AuthenticationError;

package/lib/authentication/index.d.ts

@@ -0,0 +1,4 @@
+import { AbstractAuthAdapter } from './AbstractAuthAdapter';
+import { AuthInterface } from './types/AuthInterface';
+import { AuthenticationError } from './AuthenticationError';
+export { AuthInterface, AbstractAuthAdapter, AuthenticationError };

package/lib/authentication/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationError = exports.AbstractAuthAdapter = void 0;
+const AbstractAuthAdapter_1 = require("./AbstractAuthAdapter");
+Object.defineProperty(exports, "AbstractAuthAdapter", { enumerable: true, get: function () { return AbstractAuthAdapter_1.AbstractAuthAdapter; } });
+const AuthenticationError_1 = require("./AuthenticationError");
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return AuthenticationError_1.AuthenticationError; } });

package/lib/authentication/middlewares/AbstractAuthMiddleware.js

@@ -0,0 +1 @@
+"use strict";

package/lib/authentication/middlewares/AuthMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { AuthAction } from '../../Auth';
+import { User } from '../../components/User';
+export default interface AuthMiddleware {
+    execute: (user: User, action: AuthAction) => void;
+}

package/lib/authentication/types/AuthInterface.d.ts

@@ -0,0 +1,9 @@
+import { User } from '../../components/User';
+export interface AuthInterface {
+    register(user: User): Promise<any>;
+    signup(login: string, password: string): Promise<any>;
+    signout(user: User): Promise<any>;
+    update(user: User, updatable: any): Promise<any>;
+    delete(user: User): Promise<any>;
+    getAuthToken(token: string): any;
+}

package/lib/backends/AbstractAdapter.d.ts

@@ -5,15 +5,25 @@ import { Filter } from './Filter';
 import { Filters } from './Filters';
 import { Query, QueryResultType } from './Query';
 import { SortAndLimit } from './SortAndLimit';
-import Middleware from './middlewares/Middleware';
+import BackendMiddleware from './middlewares/Middleware';
+import { MiddlewareParams } from './middlewares/types/MiddlewareParams';
+interface BM extends BackendMiddleware {
+}
 export declare abstract class AbstractAdapter implements BackendInterface {
+    static PKEY_IDENTIFIER: any;
     protected _alias: string;
     protected _params: BackendParameters;
-    protected _middlewares: Middleware[];
+    protected _middlewares: BM[];
     constructor(params?: BackendParameters);
     setParam(key: BackendParametersKeys, value: any): void;
     getParam(key: BackendParametersKeys): any;
-    addMiddleware(middleware: Middleware): void;
+    addMiddleware(middleware: BM): void;
+    /**
+     * Returns true if a given middleware is attached
+     * @param className
+     * @returns boolean
+     */
+    hasMiddleware(className: string): boolean;
     set alias(alias: string);
     get alias(): string;
     getCollection(dao: DataObjectClass<any>): string | undefined;
@@ -28,7 +38,8 @@ export declare abstract class AbstractAdapter implements BackendInterface {
      * @returns Array
      */
     query(query: Query<any>): Promise<QueryResultType<DataObjectClass<any>>>;
-    abstract find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined): Promise<QueryResultType<any>>;
+    abstract find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined, parent: any): Promise<QueryResultType<any>>;
     log(message: string): void;
-    executeMiddlewares(dataObject: DataObjectClass<any>, action: BackendAction): Promise<DataObjectClass<any>>;
+    executeMiddlewares(dataObject: DataObjectClass<any>, action: BackendAction, params?: MiddlewareParams): Promise<DataObjectClass<any>>;
 }
+export {};

package/lib/backends/AbstractAdapter.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractAdapter = void 0;
+const BackendError_1 = require("./BackendError");
 class AbstractAdapter {
     constructor(params = {}) {
         this._alias = '';
@@ -17,6 +18,7 @@ class AbstractAdapter {
         this._middlewares = [];
         this._alias = params.alias || '';
         this._middlewares = params.middlewares || [];
+        this._params = params;
     }
     setParam(key, value) {
         this._params[key] = value;
@@ -25,8 +27,25 @@ class AbstractAdapter {
         return this._params[key];
     }
     addMiddleware(middleware) {
+        if (this.hasMiddleware(middleware.constructor.name)) {
+            throw new BackendError_1.BackendError(`Middleware '${middleware.constructor.name}' is already attached`);
+        }
         this._middlewares.push(middleware);
     }
+    /**
+     * Returns true if a given middleware is attached
+     * @param className
+     * @returns boolean
+     */
+    hasMiddleware(className) {
+        let has = false;
+        this._middlewares.forEach((middleware) => {
+            if (middleware.constructor.name === className) {
+                has = true;
+            }
+        });
+        return has;
+    }
     set alias(alias) {
         this._alias = alias;
     }
@@ -34,7 +53,7 @@ class AbstractAdapter {
         return this._alias;
     }
     getCollection(dao) {
-        return dao.uri.collection; //|| dao.uri.class.name.toLowerCase() //class.COLLECTION
+        return dao.uri.collection;
     }
     /**
      * Process Query instance and return result
@@ -43,7 +62,10 @@ class AbstractAdapter {
      */
     query(query) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.find(yield query.obj.daoFactory(), query.filters, query.sortAndLimit);
+            const dao = yield query.obj.daoFactory();
+            if (query.parent) {
+            }
+            return yield this.find(dao, query.filters, query.sortAndLimit, query.parent);
         });
     }
     log(message) {
@@ -51,13 +73,14 @@ class AbstractAdapter {
             console.log(message);
         }
     }
-    executeMiddlewares(dataObject, action) {
+    executeMiddlewares(dataObject, action, params) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const middleware of this._middlewares) {
-                yield middleware.execute(dataObject, action);
+                yield middleware.execute(dataObject, action, params);
             }
             return dataObject;
         });
     }
 }
 exports.AbstractAdapter = AbstractAdapter;
+AbstractAdapter.PKEY_IDENTIFIER = 'id';

package/lib/backends/Filters.d.ts

@@ -2,9 +2,10 @@ import { Filter } from './Filter';
 export interface FiltersType {
     or?: Filter[];
     and?: Filter[];
+    base?: string;
 }
 export declare class Filters implements FiltersType {
     or?: Filter[];
     and?: Filter[];
-    constructor(or: Filter[] | undefined, and: Filter[] | undefined);
+    constructor(or?: Filter[], and?: Filter[]);
 }

package/lib/backends/Query.d.ts

@@ -28,16 +28,20 @@ export declare enum returnAs {
 }
 export declare class Query<T extends typeof BaseObjectCore> {
     protected _obj: T;
-    protected _params: any;
+    protected _parent: T | undefined;
     filters: Filter[];
     sortings: Sorting[];
     limits: Limits;
     meta: any;
-    constructor(obj: T, params?: {
-        [x: string]: any;
-    });
+    constructor(obj: T, parent?: T);
     get obj(): T;
-    where(param: Filter | string, value?: any, operator?: any): this;
+    get parent(): T | undefined;
+    /**
+     * Declare query parent record
+     * This may be need in some NoSQL backend to query subcollections
+     */
+    set parent(parent: T | undefined);
+    where(param: Filter | string | any, value?: any, operator?: any): this;
     sortBy(param: Sorting | string, order?: any): this;
     setLimits(limits: Limits): this;
     offset(offset?: number): this;

package/lib/backends/Query.js

@@ -26,9 +26,9 @@ var returnAs;
     returnAs["AS_IS"] = "asIs";
 })(returnAs || (exports.returnAs = returnAs = {}));
 class Query {
-    constructor(obj, params = {}) {
+    constructor(obj, parent) {
         this._obj = obj;
-        this._params = params; // just in case
+        this._parent = parent;
         this.filters = [];
         this.sortings = [];
         this.limits = new Limits_1.Limits();
@@ -37,8 +37,17 @@ class Query {
     get obj() {
         return this._obj;
     }
+    get parent() {
+        return this._parent;
+    }
+    /**
+     * Declare query parent record
+     * This may be need in some NoSQL backend to query subcollections
+     */
+    set parent(parent) {
+        this._parent = parent;
+    }
     where(param, value = null, operator = 'equals') {
-        console.log(`received value`, value);
         if (typeof param == 'object') {
             this.filters.push(param);
         }
@@ -96,7 +105,7 @@ class Query {
             return { items: instances, meta };
         });
     }
-    execute(as = returnAs.AS_DATAOBJECTS, backend = Core_1.Core.getBackend()) {
+    execute(as = returnAs.AS_DATAOBJECTS, backend = Core_1.Core.getBackend(this._obj.DEFAULT_BACKEND)) {
         return __awaiter(this, void 0, void 0, function* () {
             //<DataObjectClass<any>[] | ObjectUri[] | Persisted<BaseObject>[]> {
             //</any><Array<T2> | Array<DataObject> | Array<ObjectUri>> {

package/lib/backends/index.d.ts

@@ -2,10 +2,11 @@ import { AbstractAdapter } from './AbstractAdapter';
 import { MockAdapter } from './MockAdapter';
 import { BackendError } from './BackendError';
 import { BackendInterface } from './types/BackendInterface';
+import * as CollectionHierarchy from './types/CollectionHierarchy';
 import { Query, QueryResultType, QueryMetaType } from './Query';
 import { Filter } from './Filter';
 import { Filters } from './Filters';
 import { Sorting } from './Sorting';
 import { Limits } from './Limits';
 import { SortAndLimit } from './SortAndLimit';
-export { BackendInterface, AbstractAdapter, BackendError, MockAdapter, Query, QueryResultType, QueryMetaType, Filter, Filters, Sorting, Limits, SortAndLimit, };
+export { BackendInterface, AbstractAdapter, BackendError, MockAdapter, Query, QueryResultType, QueryMetaType, Filter, Filters, Sorting, Limits, SortAndLimit, CollectionHierarchy, };

package/lib/backends/index.js

@@ -1,12 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SortAndLimit = exports.Limits = exports.Sorting = exports.Filters = exports.Filter = exports.Query = exports.MockAdapter = exports.BackendError = exports.AbstractAdapter = void 0;
+exports.CollectionHierarchy = exports.SortAndLimit = exports.Limits = exports.Sorting = exports.Filters = exports.Filter = exports.Query = exports.MockAdapter = exports.BackendError = exports.AbstractAdapter = void 0;
 const AbstractAdapter_1 = require("./AbstractAdapter");
 Object.defineProperty(exports, "AbstractAdapter", { enumerable: true, get: function () { return AbstractAdapter_1.AbstractAdapter; } });
 const MockAdapter_1 = require("./MockAdapter");
 Object.defineProperty(exports, "MockAdapter", { enumerable: true, get: function () { return MockAdapter_1.MockAdapter; } });
 const BackendError_1 = require("./BackendError");
 Object.defineProperty(exports, "BackendError", { enumerable: true, get: function () { return BackendError_1.BackendError; } });
+const CollectionHierarchy = __importStar(require("./types/CollectionHierarchy"));
+exports.CollectionHierarchy = CollectionHierarchy;
 const Query_1 = require("./Query");
 Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return Query_1.Query; } });
 const Filter_1 = require("./Filter");

package/lib/backends/middlewares/InjectKeywordsMiddleware.d.ts

@@ -1,9 +1,9 @@
 import { DataObjectClass } from '../../components';
 import { BackendAction } from '../../Backend';
-import Middleware from './Middleware';
+import BackendMiddleware from './Middleware';
 export interface InjectKeywordsMiddlewareParams {
 }
-export declare class InjectKeywordsMiddleware implements Middleware {
+export declare class InjectKeywordsMiddleware implements BackendMiddleware {
     execute(dataObject: DataObjectClass<any>, action: BackendAction): void;
     protected _createKeywords(dataObject: DataObjectClass<any>): string[];
 }

package/lib/backends/middlewares/InjectMetaMiddleware.d.ts

@@ -1,12 +1,13 @@
 import { DataObjectClass } from '../../components';
 import { BackendAction } from '../../Backend';
-import { UserCore } from '../../components/User';
-import Middleware from './Middleware';
+import { User } from '../../components/User';
+import BackendMiddleware from './Middleware';
+import { MiddlewareParams } from './types/MiddlewareParams';
 export interface InjectMetaMiddlewareParams {
-    user: UserCore;
+    user: User;
 }
-export declare class InjectMetaMiddleware implements Middleware {
-    protected _user: UserCore;
+export declare class InjectMetaMiddleware implements BackendMiddleware {
+    protected _user: User;
     constructor(params: InjectMetaMiddlewareParams);
-    execute(dataObject: DataObjectClass<any>, action: BackendAction): void;
+    execute(dataObject: DataObjectClass<any>, action: BackendAction, params?: MiddlewareParams): void;
 }

package/lib/backends/middlewares/InjectMetaMiddleware.js

@@ -2,24 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InjectMetaMiddleware = void 0;
 const Backend_1 = require("../../Backend");
+const Core_1 = require("../../Core");
 class InjectMetaMiddleware {
     constructor(params) {
         this._user = params.user;
     }
-    execute(dataObject, action) {
+    execute(dataObject, action, params) {
+        Core_1.Core.log(`[MDW] Executing Middleware ${this.constructor.name}`);
+        const date = params && params.useDateFormat ? (new Date()).toISOString() : Date.now();
         switch (action) {
             // add properties existence validation
             case Backend_1.BackendAction.CREATE:
                 dataObject.set('createdBy', this._user);
-                dataObject.set('createdAt', Date.now());
+                dataObject.set('createdAt', date);
                 break;
             case Backend_1.BackendAction.UPDATE:
                 dataObject.set('updatedBy', this._user);
-                dataObject.set('updatedAt', Date.now());
+                dataObject.set('updatedAt', date);
                 break;
             case Backend_1.BackendAction.DELETE:
                 dataObject.set('deletedBy', this._user);
-                dataObject.set('deletedAt', Date.now());
+                dataObject.set('deletedAt', date);
                 break;
             default:
                 break;

package/lib/backends/middlewares/Middleware.d.ts

@@ -1,5 +1,5 @@
 import { BackendAction } from '../../Backend';
 import { DataObjectClass } from '../../components';
-export default interface Middleware {
-    execute: (dataObject: DataObjectClass<any>, action: BackendAction) => void;
+export default interface BackendMiddleware {
+    execute: (dataObject: DataObjectClass<any>, action: BackendAction, params?: any) => void;
 }

package/lib/backends/middlewares/types/MiddlewareParams.d.ts

@@ -0,0 +1,3 @@
+export type MiddlewareParams = {
+    useDateFormat?: boolean;
+};

package/lib/backends/middlewares/types/MiddlewareParams.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/backends/types/BackendInterface.d.ts

@@ -9,5 +9,5 @@ export interface BackendInterface {
     update(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
     delete(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
     query(query: Query<any>): Promise<QueryResultType<DataObjectClass<any>>>;
-    find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined): Promise<QueryResultType<DataObjectClass<any>>>;
+    find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined, parent: any): Promise<QueryResultType<DataObjectClass<any>>>;
 }

package/lib/backends/types/CollectionHierarchy.d.ts

@@ -0,0 +1,3 @@
+export declare const STANDARD = 1;
+export declare const SUBCOLLECTION = 2;
+export declare const SUBCOLLECTION_GROUP = 3;

package/lib/backends/types/CollectionHierarchy.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBCOLLECTION_GROUP = exports.SUBCOLLECTION = exports.STANDARD = void 0;
+exports.STANDARD = 1;
+exports.SUBCOLLECTION = 2;
+exports.SUBCOLLECTION_GROUP = 3;

package/lib/components/AbstractObject.d.ts

@@ -1,8 +1,10 @@
 import { DataObjectClass } from './types/DataObjectClass';
-import { DataObjectProperties } from '../properties/';
+import { DataObjectProperties } from '../properties';
 export declare abstract class AbstractObject {
     static PROPS_DEFINITION: DataObjectProperties;
     static COLLECTION: string | undefined;
+    static PARENT_PROP: string | undefined;
+    static DEFAULT_BACKEND: string;
     static LABEL_KEY: string;
     protected _dataObject: DataObjectClass<any>;
     constructor(dao: DataObjectClass<any>);