@quatrain/core 0.5.6 → 1.0.0-beta10

package/lib/backends/Query.js

@@ -23,18 +23,30 @@ var returnAs;
     returnAs["AS_OBJECTURIS"] = "objectUris";
     returnAs["AS_DATAOBJECTS"] = "dataObjects";
     returnAs["AS_INSTANCES"] = "classInstances";
+    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();
+        this.meta = {};
     }
     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') {
         if (typeof param == 'object') {
             this.filters.push(param);
@@ -42,7 +54,7 @@ class Query {
         else {
             if (operator === 'equals' && Array.isArray(value)) {
                 // auto-convert operator if value is an array
-                operator = 'containsAny';
+                operator = 'contains'; // Any'
             }
             this.filters.push(new Filter_1.Filter(param, value, operator));
         }
@@ -79,22 +91,23 @@ class Query {
     }
     fetchAsUri(backend = Core_1.Core.getBackend()) {
         return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this.fetch(backend);
-            return yield Promise.all(result.map((dao) => dao.uri));
+            const { items, meta } = yield this.fetch(backend);
+            return { items: yield Promise.all(items.map((dao) => dao.uri)), meta };
         });
     }
     fetchAsInstances(backend = Core_1.Core.getBackend()) {
         return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this.fetch(backend);
+            const { items, meta } = yield this.fetch(backend);
             const instances = [];
-            for (const item of result) {
+            for (const item of items) {
                 instances.push(this._obj.fromDataObject(item));
             }
-            return instances;
+            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>> {
             try {
                 switch (as) {

package/lib/backends/index.d.ts

@@ -1,10 +1,12 @@
-import { AbstractAdapter, BackendInterface, BackendParameters } from './AbstractAdapter';
+import { AbstractAdapter } from './AbstractAdapter';
 import { MockAdapter } from './MockAdapter';
 import { BackendError } from './BackendError';
-import { Query } from './Query';
+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 { AbstractAdapter, BackendInterface, BackendParameters, BackendError, MockAdapter, Query, 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

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

package/lib/backends/middlewares/InjectKeywordsMiddleware.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectKeywordsMiddleware = void 0;
+const Backend_1 = require("../../Backend");
+const properties_1 = require("../../properties");
+class InjectKeywordsMiddleware {
+    execute(dataObject, action) {
+        if (!dataObject.has('keywords')) {
+            dataObject.addProperty(new properties_1.ArrayProperty({ name: 'keywords' }));
+        }
+        switch (action) {
+            case Backend_1.BackendAction.CREATE:
+            case Backend_1.BackendAction.UPDATE:
+                dataObject.set('keywords', this._createKeywords(dataObject));
+                break;
+            default:
+                break;
+        }
+        return;
+    }
+    _createKeywords(dataObject) {
+        const keywords = [];
+        Object.keys(dataObject.properties)
+            .filter((key) => dataObject.get(key).fullSearch === true)
+            .forEach((key) => {
+            const val = dataObject.val(key);
+            if (val) {
+                val.toLowerCase()
+                    .split(' ')
+                    .forEach((word) => {
+                    let seq = '';
+                    word
+                        .split('')
+                        .splice(0, 15)
+                        .forEach((letter) => {
+                        seq += letter;
+                        if (seq.length > 1) {
+                            keywords.push(seq);
+                        }
+                    });
+                });
+            }
+        });
+        return [...new Set(keywords)];
+    }
+}
+exports.InjectKeywordsMiddleware = InjectKeywordsMiddleware;

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

@@ -1,13 +1,13 @@
 import { DataObjectClass } from '../../components';
 import { BackendAction } from '../../Backend';
 import { User } from '../../components/User';
-import Middleware from './Middleware';
-import { Proxy } from '../../components/types/ProxyConstructor';
+import BackendMiddleware from './Middleware';
+import { MiddlewareParams } from './types/MiddlewareParams';
 export interface InjectMetaMiddlewareParams {
-    user: Proxy<User>;
+    user: User;
 }
-export declare class InjectMetaMiddleware implements Middleware {
-    protected _user: Proxy<User>;
+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.core.dataObject.uri);
-                dataObject.set('createdAt', Date.now());
+                dataObject.set('createdBy', this._user);
+                dataObject.set('createdAt', date);
                 break;
             case Backend_1.BackendAction.UPDATE:
-                dataObject.set('updatedBy', this._user.core.dataObject.uri);
-                dataObject.set('updatedAt', Date.now());
+                dataObject.set('updatedBy', this._user);
+                dataObject.set('updatedAt', date);
                 break;
             case Backend_1.BackendAction.DELETE:
-                dataObject.set('deletedBy', this._user.core.dataObject.uri);
-                dataObject.set('deletedAt', Date.now());
+                dataObject.set('deletedBy', this._user);
+                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

@@ -0,0 +1,13 @@
+import { DataObjectClass } from '../../components';
+import { Filter } from '../Filter';
+import { Filters } from '../Filters';
+import { Query, QueryResultType } from '../Query';
+import { SortAndLimit } from '../SortAndLimit';
+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<QueryResultType<DataObjectClass<any>>>;
+    find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined, parent: any): Promise<QueryResultType<DataObjectClass<any>>>;
+}

package/lib/backends/types/BackendInterface.js

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

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/common/statuses.d.ts

@@ -1,11 +1,14 @@
 export declare const CREATED = "created";
 export declare const PENDING = "pending";
+export declare const QUEUED = "queued";
 export declare const ACTIVE = "active";
+export declare const COMPLETED = "completed";
 export declare const ERROR = "error";
 export declare const TEST = "test";
 export declare const SUSPENDED = "suspended";
 export declare const DELETABLE = "deletable";
 export declare const DELETED = "deleted";
+export declare const DISABLED = "disabled";
 export declare const DONE = "done";
 export declare const MAINTENANCE = "maintenance";
 export declare const UNKNOWN = "unknown";

package/lib/common/statuses.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UNKNOWN = exports.MAINTENANCE = exports.DONE = exports.DELETED = exports.DELETABLE = exports.SUSPENDED = exports.TEST = exports.ERROR = exports.ACTIVE = exports.PENDING = exports.CREATED = void 0;
+exports.UNKNOWN = exports.MAINTENANCE = exports.DONE = exports.DISABLED = exports.DELETED = exports.DELETABLE = exports.SUSPENDED = exports.TEST = exports.ERROR = exports.COMPLETED = exports.ACTIVE = exports.QUEUED = exports.PENDING = exports.CREATED = void 0;
 exports.CREATED = 'created';
 exports.PENDING = 'pending';
+exports.QUEUED = 'queued';
 exports.ACTIVE = 'active';
+exports.COMPLETED = 'completed';
 exports.ERROR = 'error';
 exports.TEST = 'test';
 exports.SUSPENDED = 'suspended';
 exports.DELETABLE = 'deletable';
 exports.DELETED = 'deleted';
+exports.DISABLED = 'disabled';
 exports.DONE = 'done';
 exports.MAINTENANCE = 'maintenance';
 exports.UNKNOWN = 'unknown';

package/lib/components/AbstractObject.d.ts

@@ -1,11 +1,18 @@
 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>);
+    /**
+     * Return property object matching key
+     * @param key string
+     * @returns
+     */
     get(key: string): any;
     set(key: string, val: any): any;
     val(key: string): any;
@@ -13,6 +20,7 @@ export declare abstract class AbstractObject {
     get path(): string;
     get uid(): any;
     get dataObject(): DataObjectClass<any>;
+    get _(): any;
     get uri(): import("./ObjectUri").ObjectUri;
     toJSON(): {
         backend: string;

package/lib/components/AbstractObject.js

@@ -14,6 +14,11 @@ class AbstractObject {
     constructor(dao) {
         this._dataObject = dao;
     }
+    /**
+     * Return property object matching key
+     * @param key string
+     * @returns
+     */
     get(key) {
         return this._dataObject.get(key);
     }
@@ -41,6 +46,9 @@ class AbstractObject {
     get dataObject() {
         return this._dataObject;
     }
+    get _() {
+        return this._dataObject.asProxy();
+    }
     get uri() {
         return this._dataObject.uri;
     }
@@ -62,5 +70,6 @@ class AbstractObject {
 }
 exports.AbstractObject = AbstractObject;
 AbstractObject.PROPS_DEFINITION = [];
+AbstractObject.DEFAULT_BACKEND = 'default';
 // Which property's value to use in backend as label for object reference
 AbstractObject.LABEL_KEY = 'name';

package/lib/components/BaseObject.d.ts

@@ -4,10 +4,10 @@ export interface BaseObject {
     name: string;
     status: string;
     createdBy?: User | ObjectUri;
-    createdAt?: number;
+    createdAt?: number | string;
     updatedBy?: User | ObjectUri;
-    updatedAt?: number;
+    updatedAt?: number | string;
     deletedBy?: User | ObjectUri;
-    deletedAt?: number;
+    deletedAt?: number | string;
 }
 export declare const BaseObjectProperties: any;

package/lib/components/BaseObject.js

@@ -37,6 +37,7 @@ exports.BaseObjectProperties = [
         type: StringProperty_1.StringProperty.TYPE,
         minLength: 1,
         maxLength: 100,
+        fullSearch: true,
         htmlType: htmlType.NAME,
     },
     {
@@ -51,6 +52,8 @@ exports.BaseObjectProperties = [
         ],
         defaultValue: statuses.CREATED,
     },
+    // the following properties may be optionally
+    // populated with a backend middleware
     {
         name: 'createdBy',
         type: ObjectProperty_1.ObjectProperty.TYPE,

package/lib/components/BaseObjectCore.d.ts

@@ -39,7 +39,7 @@ export declare class BaseObjectCore extends AbstractObject implements BaseObject
      * @param child
      * @returns
      */
-    static fromObject<T extends BaseObject>(src: T, child?: any): Proxy<T>;
+    static fromObject<T extends BaseObject>(src: T, child?: any): any;
     static factory(src?: string | ObjectUri | BaseObject | undefined, child?: any): Promise<any>;
     /**
      * Fetches an object from its backend path
@@ -52,9 +52,22 @@ export declare class BaseObjectCore extends AbstractObject implements BaseObject
      * @param dao
      * @returns
      */
-    static fromDataObject<T extends BaseObject>(dao: DataObjectClass<any>): T;
+    static fromDataObject<T extends BaseObject>(dao: DataObjectClass<any>): any;
+    /**
+     * Wrap instance into proxy to get access to properties
+     * @returns Proxy
+     */
     protected toProxy<T extends BaseObject>(): Proxy<Proxy<T>>;
     asReference(): any;
-    query(): Query<any>;
+    /**
+     * Create a query based on given class where parent is current instance
+     * @param obj
+     * @returns Query
+     */
+    query(obj: any): Query<any>;
+    /**
+     * Create a query based on current class
+     * @returns Query
+     */
     static query(): Query<typeof BaseObjectCore>;
 }

package/lib/components/BaseObjectCore.js

@@ -33,7 +33,10 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
                 base.push(property);
             }
         });
-        const dao = DataObject_1.DataObject.factory({ properties: base });
+        const dao = DataObject_1.DataObject.factory({
+            properties: base,
+            parentProp: this.PARENT_PROP,
+        });
         dao.uri.class = child;
         return dao;
     }
@@ -63,7 +66,7 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
         dao.uri.class = child;
         dao.populateFromData(src);
         const obj = new this(dao);
-        return obj.toProxy();
+        return obj;
     }
     static factory(src = undefined, child = this) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -100,8 +103,12 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
      */
     static fromDataObject(dao) {
         const obj = new this(dao);
-        return obj.toProxy();
+        return obj; //.toProxy()
     }
+    /**
+     * Wrap instance into proxy to get access to properties
+     * @returns Proxy
+     */
     toProxy() {
         return new ProxyConstructor_1.ProxyConstructor(this, {
             get: (target, prop) => {
@@ -142,9 +149,18 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
     asReference() {
         return this._dataObject.toReference();
     }
-    query() {
-        return new Query_1.Query(this.constructor.prototype);
+    /**
+     * Create a query based on given class where parent is current instance
+     * @param obj
+     * @returns Query
+     */
+    query(obj) {
+        return new Query_1.Query(obj, this);
     }
+    /**
+     * Create a query based on current class
+     * @returns Query
+     */
     static query() {
         return new Query_1.Query(this);
     }

package/lib/components/BaseRepository.d.ts

@@ -1,24 +1,25 @@
-import { BackendInterface } from '../backends/AbstractAdapter';
-import { Query } from '../backends/Query';
+import { Query, QueryResultType } from '../backends/Query';
 import { BaseObjectCore } from './BaseObjectCore';
 import { DataObjectClass } from './types/DataObjectClass';
-import Payload from './types/Payload';
-import RepositoryClass from './types/RepositoryClass';
 import { BaseObject } from './BaseObject';
-import { Persisted } from './types/Persisted';
-import { Proxy } from './types/ProxyConstructor';
+import { BackendInterface } from '../backends/types/BackendInterface';
 /**
  * CRUD methods for models/entities inheriting from BaseObject
  * Extend this by passing the typeof of the desired class to the constructor
  */
-export default class BaseRepository<T extends BaseObject> implements RepositoryClass<T> {
-    protected model: typeof BaseObjectCore;
+export default class BaseRepository<T extends BaseObject> {
+    protected _model: typeof BaseObjectCore;
     backendAdapter: BackendInterface;
     constructor(model: typeof BaseObjectCore, backendAdapter?: BackendInterface);
     protected getDataObjectFromUid(uid: string): Promise<DataObjectClass<any>>;
-    create(obj: Proxy<T>, uid?: string): Promise<Persisted<T>>;
-    read(uid: string): Promise<Persisted<T>>;
-    update(obj: Proxy<T>): Promise<Persisted<T>>;
-    delete(uid: string): Promise<void>;
-    query(query: Query<typeof BaseObjectCore>): Promise<Payload<Persisted<T>>>;
+    protected getDataObjectFromPath(path: string): Promise<DataObjectClass<any>>;
+    create<B extends BaseObjectCore>(obj: B, uid?: string): Promise<any>;
+    read(key: string): Promise<any>;
+    update(obj: BaseObjectCore): Promise<any>;
+    /**
+     * delete object in its backend
+     * @param uid string
+     */
+    delete(uid: string): Promise<DataObjectClass<any>>;
+    query(query: Query<any>): Promise<QueryResultType<T>>;
 }

package/lib/components/BaseRepository.js

@@ -43,34 +43,53 @@ const RESOURCE_GONE_ERROR = `The resource you are trying to access has been dele
  */
 class BaseRepository {
     constructor(model, backendAdapter = Core_1.Core.getBackend()) {
-        this.model = model;
+        this._model = model;
         this.backendAdapter = backendAdapter;
     }
     getDataObjectFromUid(uid) {
         return __awaiter(this, void 0, void 0, function* () {
-            const collection = this.model.COLLECTION || this.model.name.toLowerCase();
+            const collection = this._model.COLLECTION || this._model.name.toLowerCase();
             const path = `${collection}/${uid}`;
-            const dataObject = yield DataObject_1.DataObject.factory({
-                properties: this.model.PROPS_DEFINITION,
+            const dataObject = DataObject_1.DataObject.factory({
+                properties: this._model.PROPS_DEFINITION,
                 uri: path,
             });
             dataObject.uid = uid;
             return dataObject;
         });
     }
+    getDataObjectFromPath(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataObject = DataObject_1.DataObject.factory({
+                properties: this._model.PROPS_DEFINITION,
+                uri: path,
+            });
+            dataObject.uid = path.substring(path.lastIndexOf('/') + 1);
+            return dataObject;
+        });
+    }
     create(obj, uid) {
         return __awaiter(this, void 0, void 0, function* () {
-            const dataObject = obj.core.dataObject;
-            const savedObj = yield this.backendAdapter.create(dataObject, uid);
-            return this.model.fromDataObject(savedObj);
+            const savedObj = yield this.backendAdapter.create(obj.dataObject, uid);
+            return this._model.fromDataObject(savedObj);
         });
     }
-    read(uid) {
+    read(key) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const dataObject = yield this.getDataObjectFromUid(uid);
+                let dataObject;
+                if (key.split('/').length <= 2) {
+                    const uid = key.indexOf('/') !== -1
+                        ? key.substring(key.lastIndexOf('/') + 1)
+                        : key;
+                    dataObject = yield this.getDataObjectFromUid(uid);
+                }
+                else {
+                    dataObject = yield this.getDataObjectFromPath(key);
+                }
                 const response = yield this.backendAdapter.read(dataObject);
-                const obj = this.model.fromDataObject(response);
+                const obj = this._model.fromDataObject(response);
+                // TODO should be moved to the backend middleware
                 if (obj.status === statuses.DELETED) {
                     throw new ResourcesErrors_1.GoneError(RESOURCE_GONE_ERROR);
                 }
@@ -89,27 +108,24 @@ class BaseRepository {
     }
     update(obj) {
         return __awaiter(this, void 0, void 0, function* () {
-            const dataObject = obj.core.dataObject;
+            const dataObject = obj.dataObject;
             const savedObj = yield this.backendAdapter.update(dataObject);
-            return this.model.fromDataObject(savedObj);
+            return this._model.fromDataObject(savedObj);
         });
     }
+    /**
+     * delete object in its backend
+     * @param uid string
+     */
     delete(uid) {
         return __awaiter(this, void 0, void 0, function* () {
             const dataObject = yield this.getDataObjectFromUid(uid);
-            yield this.backendAdapter.delete(dataObject);
+            return yield this.backendAdapter.delete(dataObject);
         });
     }
     query(query) {
         return __awaiter(this, void 0, void 0, function* () {
-            const items = (yield query.fetchAsInstances(this.backendAdapter));
-            const count = yield this.backendAdapter.count(query);
-            const meta = {
-                count,
-                updatedAt: new Date().getTime(),
-            };
-            const payload = { items, meta };
-            return payload;
+            return yield query.fetchAsInstances(this.backendAdapter);
         });
     }
 }