@quatrain/core 0.3.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,4 +1,5 @@
 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;
@@ -6,6 +7,10 @@ export declare type BackendRegistry<T extends AbstractAdapter> = {
 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: {
@@ -13,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 MockAdapter_1 = require("./backends/MockAdapter");
+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 MockAdapter_1.MockAdapter({ alias: '@mock' }),
-};
+Core.logger = console.log;
+Core._backends = {};

package/lib/backends/AbstractAdapter.d.ts

@@ -1,5 +1,4 @@
-import { DataObjectClass } from '../components';
-import { BaseObjectClass } from '../components/types/BaseObjectClass';
+import { DataObjectClass } from '../components/types/DataObjectClass';
 import { Filter } from './Filter';
 import { Filters } from './Filters';
 import { Query } from './Query';
@@ -15,37 +14,52 @@ export interface BackendRecordType {
 /**
  * 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 BaseObjectClass> {
-    create(dataObject: DataObjectClass, desiredUid: string | undefined): Promise<DataObjectClass>;
-    read(param: string | DataObjectClass): Promise<DataObjectClass>;
-    update(dataObject: DataObjectClass): Promise<DataObjectClass>;
-    delete(dataObject: DataObjectClass): Promise<DataObjectClass>;
-    query(query: Query<any>): Promise<DataObjectClass[]>;
-    find(dataObject: DataObjectClass, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined): Promise<DataObjectClass[] | 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,31 +1,23 @@
 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';
 import { DataObjectClass } from '../components/types/DataObjectClass';
-import { BaseObjectClass } from '../components/types/BaseObjectClass';
-export declare class MockAdapter<T extends BaseObjectClass> extends AbstractAdapter implements BackendInterface<T> {
+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 dao2backend(data: BackendRecordType): Promise<any>;
-    static getFixtures(): any;
+    static getFixtures(): any[];
     static getFixture(key: string): any;
-    create(dataObject: DataObjectClass): Promise<DataObjectClass>;
-    read(dataObject: DataObjectClass): Promise<DataObjectClass>;
-    update(dataObject: DataObjectClass): Promise<DataObjectClass>;
-    delete(dataObject: DataObjectClass): Promise<DataObjectClass>;
-    /**
-     * Process Query instance and return result
-     * @param query
-     * @returns Array
-     */
-    query(query: Query<any>): Promise<DataObjectClass[]>;
-    find(dataObject: DataObjectClass, filters?: Filters | Filter[] | undefined, pagination?: SortAndLimit | undefined): Promise<DataObjectClass[]>;
+    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

@@ -11,20 +11,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockAdapter = void 0;
 const AbstractAdapter_1 = require("./AbstractAdapter");
-const statuses_1 = require("../statuses");
 const ObjectUri_1 = require("../components/ObjectUri");
-const Core_1 = require("../Core");
 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.path) {
             MockAdapter._fixtures[data.path] = this.dao2backend(data);
-            Core_1.Core.defaultBackend = '@mock';
         }
         else {
             throw new Error(`Can't inject data without a path`);
@@ -51,72 +49,100 @@ class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
         return MockAdapter._fixtures[key];
     }
     create(dataObject) {
-        const uri = `${dataObject.uri.class.name.toLowerCase()}/${faker_1.faker.random.alphaNumeric(12)}`;
-        MockAdapter.inject(Object.assign(Object.assign({}, dataObject.toJSON()), { uid: uri, path: uri }));
-        if (this._params.injectMeta) {
-            dataObject.set('createdBy', Core_1.Core.currentUser);
-            dataObject.set('createdAt', Date.now());
-        }
+        const uri = `${this.getCollection(dataObject)}/${faker_1.faker.random.alphaNumeric(12)}`;
         dataObject.uri = new ObjectUri_1.ObjectUri(uri);
-        return new Promise(() => dataObject);
+        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 __awaiter(this, void 0, void 0, function* () {
-            return new Promise(() => dataObject);
+            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) {
         return __awaiter(this, void 0, void 0, function* () {
-            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];
+            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();
-            }
-            return new Promise(() => dataObject);
+                resolve(dataObject);
+            });
         });
     }
-    /**
-     * Process Query instance and return result
-     * @param query
-     * @returns Array
-     */
-    query(query) {
+    deleteCollection(collection, batchSize) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.find(yield query.obj.daoFactory(), 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* () {
             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 (result.length <= limit) {
+                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);
-                                if (typeof prop === 'object' &&
-                                    prop.constructor.name === 'ObjectProperty') {
-                                    if (filter.value instanceof ObjectUri_1.ObjectUri &&
-                                        prop.val() !== filter.value.path) {
-                                        keep = false;
-                                        return;
+                                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 {

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

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;
+}

package/lib/backends/middlewares/InjectMetaMiddleware.js

@@ -0,0 +1,50 @@
+"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.InjectMetaMiddleware = void 0;
+const actions = __importStar(require("../../Backend"));
+class InjectMetaMiddleware {
+    constructor(params) {
+        this._user = params.user;
+    }
+    execute(dataObject, action) {
+        switch (action) {
+            // add properties existence validation
+            case actions.CREATE:
+                dataObject.set('createdBy', this._user);
+                dataObject.set('createdAt', Date.now());
+            case actions.UPDATE:
+                dataObject.set('updatedBy', this._user);
+                dataObject.set('updatedAt', Date.now());
+            case actions.DELETE:
+                dataObject.set('deletedBy', this._user);
+                dataObject.set('deleteddAt', Date.now());
+            default:
+                break;
+        }
+        return;
+    }
+}
+exports.InjectMetaMiddleware = InjectMetaMiddleware;

package/lib/components/AbstractObject.d.ts

@@ -1,23 +1,26 @@
 import { DataObjectClass } from './types/DataObjectClass';
 import { DataObjectProperties } from '../properties/';
+import { Query } from '../backends/Query';
 export declare abstract class AbstractObject {
     static PROPS_DEFINITION: DataObjectProperties;
     static COLLECTION: string;
     static LABEL_KEY: string;
-    protected _dataObject: DataObjectClass;
-    constructor(dao: DataObjectClass);
+    protected _dataObject: DataObjectClass<any>;
+    constructor(dao: DataObjectClass<any>);
     get(key: string): any;
     set(key: string, val: any): any;
     val(key: string): any;
     get backend(): any;
     get path(): string;
     get uid(): any;
-    get dataObject(): DataObjectClass;
+    get dataObject(): DataObjectClass<any>;
     get uri(): import("./ObjectUri").ObjectUri;
     toJSON(): {
         backend: string;
         ref: string;
-        label: string | undefined;
+        label: string;
     };
-    save(): Promise<DataObjectClass>;
+    save(): Promise<DataObjectClass<any>>;
+    delete(): Promise<DataObjectClass<any>>;
+    static query(): Query<typeof AbstractObject>;
 }

package/lib/components/AbstractObject.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractObject = void 0;
+const Query_1 = require("../backends/Query");
 class AbstractObject {
     constructor(dao) {
         this._dataObject = dao;
@@ -54,6 +55,14 @@ class AbstractObject {
             return yield this._dataObject.save();
         });
     }
+    delete() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._dataObject.delete();
+        });
+    }
+    static query() {
+        return new Query_1.Query(this);
+    }
 }
 exports.AbstractObject = AbstractObject;
 _a = AbstractObject;

package/lib/components/BaseObject.d.ts

@@ -8,8 +8,8 @@ export declare class BaseObject extends AbstractObject implements BaseObjectClas
     static getProperty(key: string): any;
     get status(): string;
     set status(status: string);
-    static daoFactory(src?: string | ObjectUri | DataObjectClass | undefined, child?: any): Promise<DataObjectClass>;
-    static factory<T extends BaseObject>(src?: string | ObjectUri | DataObjectClass | undefined, child?: any): Promise<T | BaseObject>;
+    static daoFactory(src?: string | ObjectUri | DataObjectClass<any> | undefined, child?: any): Promise<DataObjectClass<any>>;
+    static factory<T extends BaseObject>(src?: string | ObjectUri | DataObjectClass<any> | undefined, child?: any): Promise<T | BaseObject>;
     asReference(): any;
     query(): Query<any>;
 }