@quatrain/core 0.2.0 → 0.3.0

package/lib/Core.d.ts

@@ -1,9 +1,11 @@
-import { AbstractAdapter } from './backends';
+import { AbstractAdapter } from './backends/AbstractAdapter';
+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;
     protected static _backends: BackendRegistry<any>;
     static definition(key: string): {
         manifest: {

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 MockAdapter_1 = require("./backends/MockAdapter");
 class Core {
     static definition(key) {
         return {
@@ -26,5 +26,5 @@ class Core {
 exports.Core = Core;
 Core.defaultBackend = '@default';
 Core._backends = {
-    '@mock': new backends_1.MockAdapter({ alias: '@mock' }),
+    '@mock': new MockAdapter_1.MockAdapter({ alias: '@mock' }),
 };

package/lib/backends/AbstractAdapter.d.ts

@@ -1,4 +1,5 @@
-import { BaseObject, DataObject } from '../components';
+import { DataObjectClass } from '../components';
+import { BaseObjectClass } from '../components/types/BaseObjectClass';
 import { Filter } from './Filter';
 import { Filters } from './Filters';
 import { Query } from './Query';
@@ -8,7 +9,8 @@ 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
@@ -28,13 +30,13 @@ export interface BackendParameters {
     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<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 declare abstract class AbstractAdapter {
     protected _alias: string;

package/lib/backends/MockAdapter.d.ts

@@ -1,11 +1,12 @@
-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';
+import { BaseObjectClass } from '../components/types/BaseObjectClass';
+export declare class MockAdapter<T extends BaseObjectClass> extends AbstractAdapter implements BackendInterface<T> {
     protected static _fixtures: any;
     /**
      * Inject fixtures data to backend adapter
@@ -13,12 +14,18 @@ export declare class MockAdapter<T extends BaseObject> extends AbstractAdapter i
      * @param data BackendRecordType
      */
     static inject(data: BackendRecordType): void;
+    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): 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[]>;
 }

package/lib/backends/MockAdapter.js

@@ -10,35 +10,54 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockAdapter = void 0;
-const _1 = require("./");
+const AbstractAdapter_1 = require("./AbstractAdapter");
 const statuses_1 = require("../statuses");
+const ObjectUri_1 = require("../components/ObjectUri");
 const Core_1 = require("../Core");
-class MockAdapter extends _1.AbstractAdapter {
+const faker_1 = require("@faker-js/faker");
+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;
+        if (data.path) {
+            MockAdapter._fixtures[data.path] = this.dao2backend(data);
             Core_1.Core.defaultBackend = '@mock';
         }
         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;
+    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());
+        }
+        dataObject.uri = new ObjectUri_1.ObjectUri(uri);
         return new Promise(() => dataObject);
     }
     read(dataObject) {
@@ -53,27 +72,73 @@ class MockAdapter extends _1.AbstractAdapter {
         });
     }
     update(dataObject) {
-        return new Promise(() => dataObject);
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise(() => 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* () {
+            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 = new ObjectUri_1.ObjectUri();
+            }
+            return new Promise(() => dataObject);
+        });
     }
+    /**
+     * Process Query instance and return result
+     * @param query
+     * @returns Array
+     */
     query(query) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.find(query.obj.dataObject, query.filters, query.sortAndLimit);
+            return this.find(yield query.obj.daoFactory(), query.filters, query.sortAndLimit);
         });
     }
     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 = [];
+            for (let key in MockAdapter.getFixtures()) {
+                let keep = true;
+                if (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;
+                                    }
+                                }
+                                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/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 { BaseObject } from '../components/BaseObject';
+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 BaseObject> {
     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<any>): 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/components/AbstractObject.d.ts

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

package/lib/components/AbstractObject.js

@@ -49,9 +49,9 @@ class AbstractObject {
         var _b;
         return typeof this.uri === 'string' ? this.uri : (_b = this.uri) === null || _b === void 0 ? void 0 : _b.toJSON();
     }
-    save(uid = undefined) {
+    save() {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this._dataObject.save(uid);
+            return yield this._dataObject.save();
         });
     }
 }

package/lib/components/BaseObject.d.ts

@@ -1,16 +1,15 @@
 import { ObjectUri } from './ObjectUri';
+import { DataObjectClass } from './types/DataObjectClass';
+import { BaseObjectClass } from './types/BaseObjectClass';
 import { AbstractObject } from './AbstractObject';
-import { DataObjectProperties } from '../properties';
-import { Query } from '../backends';
-export declare class BaseObject extends AbstractObject {
-    static PROPS_DEFINITION: DataObjectProperties;
+import { Query } from '../backends/Query';
+export declare class BaseObject extends AbstractObject implements BaseObjectClass {
+    static PROPS_DEFINITION: any;
+    static getProperty(key: string): any;
     get status(): string;
     set status(status: string);
-    static factory<T extends BaseObject>(src?: string | ObjectUri | object | undefined): Promise<T | BaseObject>;
-    asReference(): {
-        label: any;
-        ref: string;
-        uri: string;
-    };
-    query(): Query<this>;
+    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>;
+    asReference(): any;
+    query(): Query<any>;
 }

package/lib/components/BaseObject.js

@@ -10,51 +10,60 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseObject = void 0;
-const DataObject_1 = require("./DataObject");
 const ObjectUri_1 = require("./ObjectUri");
+const DataObject_1 = require("./DataObject");
 const AbstractObject_1 = require("./AbstractObject");
 const BaseObjectProperties_1 = require("./BaseObjectProperties");
-const backends_1 = require("../backends");
+const Query_1 = require("../backends/Query");
 class BaseObject extends AbstractObject_1.AbstractObject {
+    static getProperty(key) {
+        return BaseObject.PROPS_DEFINITION.find((prop) => prop.name === key);
+    }
     get status() {
         return this._dataObject.val('status');
     }
     set status(status) {
         this._dataObject.set('status', status);
     }
-    static factory(src = undefined) {
+    static daoFactory(src = undefined, child = this) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // merge base properties with additional or redefined ones
-                const base = BaseObjectProperties_1.BaseObjectProperties;
-                // this.PROPS_DEFINITION &&
-                this.PROPS_DEFINITION.forEach((property) => {
-                    // manage parent properties potential redeclaration
-                    const found = base.findIndex((el) => el.name === property.name);
-                    if (found !== -1) {
-                        base[found] = Object.assign(base[found], property);
-                    }
-                    else {
-                        base.push(property);
-                    }
-                });
-                //console.log('props to add', JSON.stringify(base))
-                // create data object
-                const dao = yield DataObject_1.DataObject.factory(this.prototype, base);
-                if (src instanceof ObjectUri_1.ObjectUri) {
-                    dao.uri = src;
-                    yield dao.populate();
-                }
-                else if (typeof src === 'string') {
-                    dao.uri.path = src;
-                    yield dao.populate();
+            // merge base properties with additional or redefined ones
+            const base = BaseObjectProperties_1.BaseObjectProperties;
+            // this.PROPS_DEFINITION &&
+            this.PROPS_DEFINITION.forEach((property) => {
+                // manage parent properties potential redeclaration
+                const found = base.findIndex((el) => el.name === property.name);
+                if (found !== -1) {
+                    base[found] = Object.assign(base[found], property);
                 }
-                else if (src instanceof Object) {
-                    dao.uri = new ObjectUri_1.ObjectUri(`${this.COLLECTION}${ObjectUri_1.ObjectUri.DEFAULT}`, Reflect.get(src, 'name'));
-                    dao.uri.collection = this.COLLECTION;
-                    yield dao.populate(src);
+                else {
+                    base.push(property);
                 }
-                return new this(dao);
+            });
+            // create data object
+            const dao = yield DataObject_1.DataObject.factory({ properties: base });
+            dao.uri.class = child;
+            if (src instanceof ObjectUri_1.ObjectUri) {
+                dao.uri = src;
+                yield dao.read();
+            }
+            else if (typeof src === 'string') {
+                dao.uri.path = src;
+                yield dao.read();
+            }
+            else if (src instanceof Object) {
+                dao.uri = new ObjectUri_1.ObjectUri(`${this.COLLECTION}${ObjectUri_1.ObjectUri.DEFAULT}`, Reflect.get(src, 'name'));
+                dao.uri.collection = this.COLLECTION;
+                yield dao.populate(src);
+            }
+            return dao;
+        });
+    }
+    static factory(src = undefined, child = this) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const dao = yield this.daoFactory(src);
+                return Reflect.construct(this, [dao]);
             }
             catch (err) {
                 console.log(err.message);
@@ -66,7 +75,7 @@ class BaseObject extends AbstractObject_1.AbstractObject {
         return this._dataObject.toReference();
     }
     query() {
-        return new backends_1.Query(this);
+        return new Query_1.Query(this.constructor.prototype);
     }
 }
 exports.BaseObject = BaseObject;

package/lib/components/BaseObjectProperties.d.ts

@@ -1,15 +1,14 @@
-import { DataObjectProperties } from '../properties';
 import * as statuses from '../statuses';
-import { User } from './User';
+import { UserClass } from './types/UserClass';
 import { ObjectUri } from './ObjectUri';
 export interface BaseObjectType {
     name: string;
     status: typeof statuses.CREATED | typeof statuses.PENDING | typeof statuses.ACTIVE | typeof statuses.DELETED;
-    createdBy?: User | ObjectUri;
+    createdBy?: UserClass | ObjectUri;
     createdAt?: number;
-    updatedBy?: User | ObjectUri;
+    updatedBy?: UserClass | ObjectUri;
     updatedAt?: number;
-    deletedBy?: User | ObjectUri;
+    deletedBy?: UserClass | ObjectUri;
     deletedAt?: number;
 }
-export declare const BaseObjectProperties: DataObjectProperties;
+export declare const BaseObjectProperties: any;

package/lib/components/BaseObjectProperties.js

@@ -24,20 +24,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseObjectProperties = void 0;
-const Property_1 = require("../properties/Property");
 const statuses = __importStar(require("../statuses"));
+const StringProperty_1 = require("../properties/StringProperty");
+const ObjectProperty_1 = require("../properties/ObjectProperty");
+const EnumProperty_1 = require("../properties/EnumProperty");
+const DateTimeProperty_1 = require("../properties/DateTimeProperty");
 exports.BaseObjectProperties = [
     {
         name: 'name',
         mandatory: true,
-        type: Property_1.Property.TYPE_STRING,
+        type: StringProperty_1.StringProperty.TYPE,
         minLength: 1,
         maxLength: 100,
     },
     {
         name: 'status',
         mandatory: true,
-        type: Property_1.Property.TYPE_ENUM,
+        type: EnumProperty_1.EnumProperty.TYPE,
         values: [
             statuses.CREATED,
             statuses.PENDING,
@@ -48,35 +51,35 @@ exports.BaseObjectProperties = [
     },
     {
         name: 'createdBy',
-        type: Property_1.Property.TYPE_OBJECT,
+        type: ObjectProperty_1.ObjectProperty.TYPE,
         instanceOf: 'User',
         mandatory: true,
         protected: true,
     },
     {
         name: 'createdAt',
-        type: Property_1.Property.TYPE_DATETIME,
+        type: DateTimeProperty_1.DateTimeProperty.TYPE,
         mandatory: true,
         protected: true,
     },
     {
         name: 'updatedBy',
-        type: Property_1.Property.TYPE_OBJECT,
+        type: ObjectProperty_1.ObjectProperty.TYPE,
         instanceOf: 'User',
     },
     {
         name: 'updatedAt',
-        type: Property_1.Property.TYPE_DATETIME,
+        type: DateTimeProperty_1.DateTimeProperty.TYPE,
     },
     {
         name: 'deletedBy',
-        type: Property_1.Property.TYPE_OBJECT,
+        type: ObjectProperty_1.ObjectProperty.TYPE,
         instanceOf: 'User',
         protected: true,
     },
     {
         name: 'deletedAt',
-        type: Property_1.Property.TYPE_DATETIME,
+        type: DateTimeProperty_1.DateTimeProperty.TYPE,
         protected: true,
     },
 ];