@quatrain/core 0.2.0 → 0.4.0

package/lib/Backend.d.ts

@@ -0,0 +1,5 @@
+export declare const CREATE = "create";
+export declare const READ = "read";
+export declare const UPDATE = "update";
+export declare const DELETE = "delete";
+export declare type BackendActions = typeof CREATE | typeof READ | typeof UPDATE | typeof DELETE;

package/lib/Backend.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE = exports.UPDATE = exports.READ = exports.CREATE = void 0;
+exports.CREATE = 'create';
+exports.READ = 'read';
+exports.UPDATE = 'update';
+exports.DELETE = 'delete';

package/lib/Core.d.ts

@@ -1,9 +1,16 @@
-import { AbstractAdapter } from './backends';
+import { AbstractAdapter } from './backends/AbstractAdapter';
+import { DataObjectClass } from './components/types/DataObjectClass';
+import { UserClass } from './components/types/UserClass';
 export declare type BackendRegistry<T extends AbstractAdapter> = {
     [x: string]: T;
 };
 export declare class Core {
     static defaultBackend: string;
+    static currentUser: UserClass;
+    static logger: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
     protected static _backends: BackendRegistry<any>;
     static definition(key: string): {
         manifest: {
@@ -11,6 +18,19 @@ export declare class Core {
             mandatory: boolean;
         };
     };
-    static addBackend(backend: AbstractAdapter, alias: string): void;
-    static getBackend(alias?: string): any;
+    static addBackend(backend: AbstractAdapter, alias: string, setDefault?: boolean): void;
+    static getBackend<T extends AbstractAdapter>(alias?: string): T;
+    /**
+     * Returns the class to use for a data object
+     * This is currently just a stub that will be implemented from config in the future
+     * @returns DataObjectClass
+     */
+    static getDataObjectClass(): DataObjectClass<any>;
+    /**
+     * Log message using defined logger
+     * This is currently just a stub that will be implemented from config in the future
+     * @param message string
+     * @param level string
+     */
+    static log(message: string, src?: string, level?: string): void;
 }

package/lib/Core.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Core = void 0;
-const backends_1 = require("./backends");
+const DataObject_1 = require("./components/DataObject");
 class Core {
     static definition(key) {
         return {
@@ -11,8 +11,11 @@ class Core {
             },
         };
     }
-    static addBackend(backend, alias) {
+    static addBackend(backend, alias, setDefault = false) {
         Core._backends[alias] = backend;
+        if (setDefault) {
+            Core.defaultBackend = alias;
+        }
     }
     static getBackend(alias = this.defaultBackend) {
         if (this._backends[alias]) {
@@ -22,9 +25,25 @@ class Core {
             throw new Error(`Unknown backend alias: '${alias}'`);
         }
     }
+    /**
+     * Returns the class to use for a data object
+     * This is currently just a stub that will be implemented from config in the future
+     * @returns DataObjectClass
+     */
+    static getDataObjectClass() {
+        return DataObject_1.DataObject.prototype;
+    }
+    /**
+     * Log message using defined logger
+     * This is currently just a stub that will be implemented from config in the future
+     * @param message string
+     * @param level string
+     */
+    static log(message, src = 'Core', level = 'NOTICE') {
+        Core.logger(`[${src}] ${message}`, level);
+    }
 }
 exports.Core = Core;
 Core.defaultBackend = '@default';
-Core._backends = {
-    '@mock': new backends_1.MockAdapter({ alias: '@mock' }),
-};
+Core.logger = console.log;
+Core._backends = {};

package/lib/backends/AbstractAdapter.d.ts

@@ -1,4 +1,4 @@
-import { BaseObject, DataObject } from '../components';
+import { DataObjectClass } from '../components/types/DataObjectClass';
 import { Filter } from './Filter';
 import { Filters } from './Filters';
 import { Query } from './Query';
@@ -8,42 +8,58 @@ import { SortAndLimit } from './SortAndLimit';
  */
 export interface BackendRecordType {
     uid: string | undefined;
-    [key: string]: string | number | boolean | any[] | Object | undefined;
+    path: string | undefined;
+    [key: string]: any;
 }
 /**
  * Backend Parameters acceptable keys
  */
-export declare type BackendParametersKeys = 'alias' | 'mapping' | 'injectMeta' | 'config' | 'fixtures' | 'softDelete' | 'debug';
+export declare type BackendParametersKeys = 'host' | 'alias' | 'mapping' | 'middlewares' | 'config' | 'fixtures' | 'softDelete' | 'debug';
 /**
  * Backend parameters interface
  */
 export interface BackendParameters {
+    host?: string;
     alias?: string;
     mapping?: {
         [x: string]: any;
     };
-    injectMeta?: boolean;
+    middlewares?: any[];
     config?: any;
     fixtures?: any;
     softDelete?: boolean;
     debug?: boolean;
 }
-export interface BackendInterface<T extends BaseObject> {
-    create(dataObject: DataObject, desiredUid: string | undefined): Promise<DataObject>;
-    read(param: string | DataObject): Promise<DataObject>;
-    update(dataObject: DataObject): Promise<DataObject>;
-    delete(dataObject: DataObject): Promise<DataObject>;
-    query(query: Query<T>): Promise<DataObject[] | T[]>;
-    find(dataObject: DataObject, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined): Promise<DataObject[] | T[]>;
+export interface BackendInterface {
+    create(dataObject: DataObjectClass<any>, desiredUid: string | undefined): Promise<DataObjectClass<any>>;
+    read(param: string | DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    update(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    delete(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    query(query: Query<any>): Promise<DataObjectClass<any>[]>;
+    find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined): Promise<DataObjectClass<any>[]>;
 }
 export declare abstract class AbstractAdapter {
     protected _alias: string;
     protected _params: BackendParameters;
-    protected _injectMeta: boolean;
-    constructor(params: BackendParameters);
+    protected _middlewares: any[];
+    constructor(params?: BackendParameters);
     setParam(key: BackendParametersKeys, value: any): void;
     getParam(key: BackendParametersKeys): any;
     set alias(alias: string);
     get alias(): string;
+    getCollection(dao: DataObjectClass<any>): any;
+    abstract create(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    abstract read(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    abstract update(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    abstract delete(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    abstract deleteCollection(collection: string, batchSize?: number): Promise<void>;
+    /**
+     * Process Query instance and return result
+     * @param query
+     * @returns Array
+     */
+    query(query: Query<any>): Promise<DataObjectClass<any>[]>;
+    abstract find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined): Promise<DataObjectClass<any>[]>;
     log(message: string): void;
+    executeMiddlewares(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
 }

package/lib/backends/AbstractAdapter.js

@@ -1,13 +1,22 @@
 "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.AbstractAdapter = void 0;
 class AbstractAdapter {
-    constructor(params) {
+    constructor(params = {}) {
         this._alias = '';
         this._params = {};
-        this._injectMeta = false;
+        this._middlewares = [];
         this._alias = params.alias || '';
-        this._injectMeta = params.injectMeta || false;
+        this._middlewares = params.middlewares || [];
     }
     setParam(key, value) {
         this._params[key] = value;
@@ -21,10 +30,29 @@ class AbstractAdapter {
     get alias() {
         return this._alias;
     }
+    getCollection(dao) {
+        return dao.uri.class.name.toLowerCase();
+    }
+    /**
+     * Process Query instance and return result
+     * @param query
+     * @returns Array
+     */
+    query(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.find(yield query.obj.daoFactory(), query.filters, query.sortAndLimit);
+        });
+    }
     log(message) {
         if (this._params['debug'] === true) {
             console.log(message);
         }
     }
+    executeMiddlewares(dataObject) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._middlewares.forEach((middleware) => __awaiter(this, void 0, void 0, function* () { return yield middleware.execute(dataObject); }));
+            return dataObject;
+        });
+    }
 }
 exports.AbstractAdapter = AbstractAdapter;

package/lib/backends/Filter.d.ts

@@ -1,8 +1,10 @@
+import { BaseObject } from '../components';
 import { FilterOperatorType } from './FilterOperators';
+export declare type FilterValueType<T extends BaseObject> = T | number | string | string[] | null;
 export interface FilterType {
     prop: string;
     operator: FilterOperatorType | undefined;
-    value: number | string | string[] | undefined;
+    value: FilterValueType<any>;
 }
 /**
  * Filter object
@@ -10,6 +12,6 @@ export interface FilterType {
 export declare class Filter implements FilterType {
     prop: string;
     operator: FilterOperatorType;
-    value: number | string | string[] | undefined;
-    constructor(prop: string, value?: number | string | string[] | undefined, operator?: FilterOperatorType);
+    value: FilterValueType<any>;
+    constructor(prop: string, value: FilterValueType<any>, operator?: FilterOperatorType);
 }

package/lib/backends/Filter.js

@@ -5,7 +5,7 @@ exports.Filter = void 0;
  * Filter object
  */
 class Filter {
-    constructor(prop, value = undefined, operator = 'equals') {
+    constructor(prop, value, operator = 'equals') {
         this.prop = prop;
         this.operator = operator;
         this.value = value;

package/lib/backends/MockAdapter.d.ts

@@ -1,24 +1,23 @@
-import { AbstractAdapter, BackendInterface } from './';
-import { BaseObject, DataObject } from '../components';
+import { AbstractAdapter, BackendInterface } from './AbstractAdapter';
 import { BackendRecordType } from './AbstractAdapter';
-import { Query } from './Query';
 import { Filter } from './Filter';
 import { Filters } from './Filters';
 import { SortAndLimit } from './SortAndLimit';
-export declare class MockAdapter<T extends BaseObject> extends AbstractAdapter implements BackendInterface<T> {
+import { DataObjectClass } from '../components/types/DataObjectClass';
+export declare class MockAdapter extends AbstractAdapter implements BackendInterface {
     protected static _fixtures: any;
     /**
      * Inject fixtures data to backend adapter
-     * Force this backend to be default one
      * @param data BackendRecordType
      */
     static inject(data: BackendRecordType): void;
-    static getFixtures(): any;
+    static dao2backend(data: BackendRecordType): Promise<any>;
+    static getFixtures(): any[];
     static getFixture(key: string): any;
-    create(dataObject: DataObject, desiredUid?: string | undefined): Promise<DataObject>;
-    read(dataObject: DataObject): Promise<DataObject>;
-    update(dataObject: DataObject): Promise<DataObject>;
-    delete(dataObject: DataObject): Promise<DataObject>;
-    query(query: Query<T>): Promise<DataObject[]>;
-    find(dataObject: DataObject, filters?: Filters | Filter[] | undefined, pagination?: SortAndLimit | undefined): Promise<DataObject[]>;
+    create(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    read(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    update(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    delete(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
+    deleteCollection(collection: string, batchSize?: number | undefined): Promise<void>;
+    find(dataObject: DataObjectClass<any>, filters?: Filters | Filter[] | undefined, pagination?: SortAndLimit | undefined): Promise<DataObjectClass<any>[]>;
 }

package/lib/backends/MockAdapter.js

@@ -10,70 +10,161 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockAdapter = void 0;
-const _1 = require("./");
-const statuses_1 = require("../statuses");
-const Core_1 = require("../Core");
-class MockAdapter extends _1.AbstractAdapter {
+const AbstractAdapter_1 = require("./AbstractAdapter");
+const ObjectUri_1 = require("../components/ObjectUri");
+const faker_1 = require("@faker-js/faker");
+const BackendError_1 = require("./BackendError");
+const NotFoundError_1 = require("./NotFoundError");
+class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
     /**
      * Inject fixtures data to backend adapter
-     * Force this backend to be default one
      * @param data BackendRecordType
      */
     static inject(data) {
-        if (data.uid) {
-            MockAdapter._fixtures[data.uid] = data;
-            Core_1.Core.defaultBackend = '@mock';
+        if (data.path) {
+            MockAdapter._fixtures[data.path] = this.dao2backend(data);
         }
         else {
-            throw new Error(`Can't inject data without uid`);
+            throw new Error(`Can't inject data without a path`);
         }
     }
+    static dao2backend(data) {
+        const processed = {};
+        Object.keys(data).forEach((key) => {
+            if (data[key] !== null &&
+                typeof data[key] === 'object' &&
+                data[key].name === 'BaseObject') {
+                processed[key] = data[key].dataObject.uri.toReference();
+            }
+            else {
+                processed[key] = data[key];
+            }
+        });
+        return processed;
+    }
     static getFixtures() {
         return MockAdapter._fixtures;
     }
     static getFixture(key) {
         return MockAdapter._fixtures[key];
     }
-    create(dataObject, desiredUid = undefined) {
-        const uri = desiredUid ||
-            `${dataObject.class.constructor.name.toLowerCase()}/${Date.now()}`;
-        MockAdapter.inject(Object.assign(Object.assign({}, dataObject.toJSON()), { uid: uri }));
-        dataObject.uri = uri;
-        return new Promise(() => dataObject);
+    create(dataObject) {
+        const uri = `${this.getCollection(dataObject)}/${faker_1.faker.random.alphaNumeric(12)}`;
+        dataObject.uri = new ObjectUri_1.ObjectUri(uri);
+        return new Promise((resolve, reject) => {
+            try {
+                MockAdapter.inject(Object.assign(Object.assign({}, dataObject.toJSON()), { uid: uri, path: uri }));
+                resolve(dataObject);
+            }
+            catch (err) {
+                reject(new BackendError_1.BackendError(err.message));
+            }
+        });
     }
     read(dataObject) {
         return __awaiter(this, void 0, void 0, function* () {
-            const path = dataObject.path;
-            const data = MockAdapter._fixtures[path];
-            if (data === undefined) {
-                throw new Error(`[Mock] No data for ${path}`);
-            }
-            this.log(`[DAO] Populating ${dataObject.path}`);
-            return yield dataObject.populate(data);
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                const path = dataObject.path;
+                const data = MockAdapter._fixtures[path];
+                if (data === undefined) {
+                    reject(new NotFoundError_1.NotFoundError(`[Mock] No data for ${path}`));
+                }
+                this.log(`[DAO] Populating ${dataObject.path}`);
+                resolve(yield dataObject.populate(data));
+            }));
         });
     }
     update(dataObject) {
-        return new Promise(() => dataObject);
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                const path = dataObject.path;
+                const data = MockAdapter._fixtures[path];
+                if (data === undefined) {
+                    reject(new NotFoundError_1.NotFoundError(`[Mock] No data for ${path}`));
+                }
+                this.log(`[DAO] Updating ${dataObject.path}`);
+                MockAdapter._fixtures[path] = Object.assign(Object.assign({}, data), dataObject.toJSON());
+                resolve(dataObject);
+            }));
+        });
     }
     delete(dataObject) {
-        if (this.getParam('softDelete') === true) {
-            dataObject.set('status', statuses_1.DELETED);
-            MockAdapter.inject(Object.assign(Object.assign({}, dataObject.toJSON()), { uid: dataObject.uid }));
-        }
-        else if (dataObject.uid !== undefined) {
-            delete MockAdapter._fixtures[dataObject.uid];
-            dataObject.uri = undefined;
-        }
-        return new Promise(() => dataObject);
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const path = dataObject.path;
+                const data = MockAdapter._fixtures[path];
+                if (data === undefined) {
+                    reject(new NotFoundError_1.NotFoundError(`[Mock] No data for ${path}`));
+                }
+                delete MockAdapter._fixtures[dataObject.path];
+                dataObject.uri = new ObjectUri_1.ObjectUri();
+                resolve(dataObject);
+            });
+        });
     }
-    query(query) {
+    deleteCollection(collection, batchSize) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.find(query.obj.dataObject, query.filters, query.sortAndLimit);
+            for (let key in MockAdapter._fixtures) {
+                if (key.startsWith(`${collection}/`)) {
+                    delete MockAdapter._fixtures[key];
+                }
+            }
+            return new Promise(() => null);
         });
     }
     find(dataObject, filters = undefined, pagination = undefined) {
         return __awaiter(this, void 0, void 0, function* () {
-            return [dataObject, dataObject];
+            const limit = (pagination === null || pagination === void 0 ? void 0 : pagination.limits.batch) || 1e10;
+            let result = [];
+            const collection = this.getCollection(dataObject);
+            // TODO filter only records matchinf collection
+            for (let key in MockAdapter.getFixtures()) {
+                let keep = true;
+                if (key.startsWith(`${collection}/`) && result.length <= limit) {
+                    const dao = yield dataObject.clone(MockAdapter.getFixture(key));
+                    if (filters) {
+                        if (Array.isArray(filters)) {
+                            filters.forEach((filter) => {
+                                const prop = dao.get(filter.prop);
+                                const val = prop.val();
+                                //console.log(filter.prop, prop)
+                                if (typeof prop === 'object') {
+                                    if (prop.constructor.name === 'ObjectProperty') {
+                                        if (filter.value instanceof ObjectUri_1.ObjectUri &&
+                                            val &&
+                                            val.ref !== filter.value.path) {
+                                            keep = false;
+                                            return;
+                                        }
+                                    }
+                                    else if (prop.constructor.name === 'CollectionProperty') {
+                                        if (filter.value instanceof ObjectUri_1.ObjectUri &&
+                                            prop.val() !== filter.value.path) {
+                                            keep = false;
+                                            return;
+                                        }
+                                    }
+                                }
+                                else {
+                                    if (prop.val() !== filter.value) {
+                                        keep = false;
+                                        return;
+                                    }
+                                }
+                            });
+                        }
+                    }
+                    if (keep) {
+                        dao.uri = new ObjectUri_1.ObjectUri(key);
+                        result.push(dao);
+                    }
+                }
+            }
+            if (pagination && pagination.sortings.length > 0) {
+                result = result.sort((a, b) => Number(a.val(pagination.sortings[0].prop) >
+                    b.val(pagination.sortings[0].prop)));
+            }
+            return result;
         });
     }
 }

package/lib/backends/NotFoundError.d.ts

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

package/lib/backends/NotFoundError.js

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

package/lib/backends/Query.d.ts

@@ -3,8 +3,16 @@ import { Limits } from './Limits';
 import { Sorting } from './Sorting';
 import { SortAndLimit } from './SortAndLimit';
 import { BackendInterface } from './AbstractAdapter';
-import { BaseObject } from '../components';
-export declare class Query<T extends BaseObject> {
+import { AbstractObject } from '../components';
+export declare const AS_OBJECTURIS = "objectUris";
+export declare const AS_DATAOBJECTS = "dataObjects";
+export declare const AS_INSTANCES = "classInstances";
+export declare enum returnAs {
+    AS_OBJECTURIS = "objectUris",
+    AS_DATAOBJECTS = "dataObjects",
+    AS_INSTANCES = "classInstances"
+}
+export declare class Query<T extends typeof AbstractObject> {
     protected _obj: T;
     protected _params: any;
     filters: Filter[];
@@ -20,5 +28,5 @@ export declare class Query<T extends BaseObject> {
     offset(offset?: number): this;
     batch(batch?: number): this;
     get sortAndLimit(): SortAndLimit;
-    execute(backend: BackendInterface<T>): Promise<import("../components").DataObject[] | T[]>;
+    execute(as?: returnAs, backend?: BackendInterface): Promise<any>;
 }

package/lib/backends/Query.js

@@ -9,15 +9,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Query = void 0;
+exports.Query = exports.returnAs = exports.AS_INSTANCES = exports.AS_DATAOBJECTS = exports.AS_OBJECTURIS = void 0;
 const Filter_1 = require("./Filter");
 const Limits_1 = require("./Limits");
 const Sorting_1 = require("./Sorting");
 const SortAndLimit_1 = require("./SortAndLimit");
+const Core_1 = require("../Core");
+exports.AS_OBJECTURIS = 'objectUris';
+exports.AS_DATAOBJECTS = 'dataObjects';
+exports.AS_INSTANCES = 'classInstances';
+var returnAs;
+(function (returnAs) {
+    returnAs["AS_OBJECTURIS"] = "objectUris";
+    returnAs["AS_DATAOBJECTS"] = "dataObjects";
+    returnAs["AS_INSTANCES"] = "classInstances";
+})(returnAs = exports.returnAs || (exports.returnAs = {}));
 class Query {
     constructor(obj, params = {}) {
         this._obj = obj;
-        //Object.keys(params).forEach((key: string) => (obj[key] = params[key]))
         this._params = params; // just in case
         this.filters = [];
         this.sortings = [];
@@ -63,9 +72,26 @@ class Query {
     get sortAndLimit() {
         return new SortAndLimit_1.SortAndLimit(this.sortings, this.limits);
     }
-    execute(backend) {
+    execute(as = returnAs.AS_DATAOBJECTS, backend = Core_1.Core.getBackend()) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield backend.find(this._obj.dataObject, this.filters, this.sortAndLimit);
+            try {
+                const result = yield backend.query(this);
+                switch (as) {
+                    case exports.AS_DATAOBJECTS:
+                        return result;
+                    case exports.AS_OBJECTURIS:
+                        return yield Promise.all(result.map((dao) => dao.uri));
+                    case exports.AS_INSTANCES:
+                        //console.log(this._obj)
+                        return yield Promise.all(result.map((dao) => Reflect.construct(this._obj, [dao])));
+                    default:
+                        throw new Error(`Unknown output mode`);
+                }
+            }
+            catch (err) {
+                console.log(err);
+                throw err;
+            }
         });
     }
 }

package/lib/backends/middlewares/AbstractMiddleware.js

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

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

@@ -0,0 +1,11 @@
+import { DataObjectClass } from '../../components';
+import { UserClass } from '../../components/types/UserClass';
+import * as actions from '../../Backend';
+export interface InjectMetaMiddlewareParams {
+    user: UserClass;
+}
+export declare class InjectMetaMiddleware {
+    protected _user: UserClass;
+    constructor(params: InjectMetaMiddlewareParams);
+    execute(dataObject: DataObjectClass<any>, action: actions.BackendActions): void;
+}