@quatrain/core 0.4.4 → 0.5.2

package/README.md

@@ -11,13 +11,114 @@ and storage.
 
 ## How to install
 
-```javascript
+```bash
 yarn install @quatrain/core
 ```
 
 Quatrain Core comes with a built-in Mock backend adapter. Other adapters are available in
 different packages. For example, a Google Firestore adapter is available:
 
-```javascript
+```bash
 yarn install @quatrain/backend-firestore
 ```
+
+## How to use
+
+### Setup
+
+```ts
+import { Core } from '@quatrain/core'
+
+Core.addBackend(myAdapter, 'myDB', true)
+```
+
+### Create a model
+
+```ts
+import { BaseObjectCore } from '@quatrain/core'
+
+export type Cat = {
+   name: string
+   color: `#${string}`
+}
+
+export class CatCore extends BaseObjectCore {
+   static COLLECTION = 'cats'
+
+   static PROPERTIES = [
+      {
+         name: 'name',
+         type: Property.STRING,
+         minLength: 1,
+         maxLength: 32,
+      },
+      {
+         name: 'color',
+         type: Property.STRING,
+         minLength: 4,
+         maxLength: 7,
+      },
+   ]
+}
+```
+
+### Instantiate a model
+
+```ts
+const catData: Cat = {
+   name: 'Garfield',
+   color: '#ffa502',
+}
+
+const garfield = CatCore.fromObject(catData)
+
+console.log(garfield.name)
+// > "Garfield"
+console.log(garfield.color)
+// > "#ffa502"
+console.log(garfield.core)
+// > CatCore { ... }
+```
+
+### Interact with backend
+
+```ts
+// Let's save Garfield in our database
+garfield.core.save()
+
+// Now, let's retrieve Garfield in the database
+const persistedGarfield = await CatCore.fromBackend('garfield')
+```
+
+### Using repositories
+
+You can use repositories as an alternative way to persist and retrieve models in your backend.
+
+This module provides a BaseRepository class that you can extend and override to apply your business logic when doing backend operations.
+
+Let's create a repository for our Cat model, that prevents us from deleting a cat.
+
+```ts
+import { Core, BackendInterface, BaseRepository } from '@quatrain/core'
+
+export default class CatRepository extends BaseRepository<Cat> {
+   constructor(backendAdapter: BackendInterface = Core.getBackend()) {
+      super(CatCore, backendAdapter)
+   }
+
+   async delete(uid: string) {
+      throw Error("Don't delete the cats!")
+   }
+}
+```
+
+Now, let's use our new CatRepository.
+
+```ts
+const repository = new CatRepository()
+
+repository.create(garfield)
+repository.read('garfield')
+repository.update(persistedGarfield)
+repository.delete('garfield') // Will throw "Don't delete the cats!"
+```

package/lib/Backend.d.ts

@@ -1,5 +1,6 @@
-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;
+export declare enum BackendAction {
+    CREATE = "create",
+    READ = "read",
+    UPDATE = "update",
+    DELETE = "delete"
+}

package/lib/Backend.js

@@ -1,7 +1,19 @@
 "use strict";
+// export const CREATE = 'create'
+// export const READ = 'read'
+// export const UPDATE = 'update'
+// export const DELETE = 'delete'
 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';
+exports.BackendAction = void 0;
+// export type BackendActions =
+//    | typeof CREATE
+//    | typeof READ
+//    | typeof UPDATE
+//    | typeof DELETE
+var BackendAction;
+(function (BackendAction) {
+    BackendAction["CREATE"] = "create";
+    BackendAction["READ"] = "read";
+    BackendAction["UPDATE"] = "update";
+    BackendAction["DELETE"] = "delete";
+})(BackendAction || (exports.BackendAction = BackendAction = {}));

package/lib/Core.d.ts

@@ -1,12 +1,12 @@
 import { AbstractAdapter } from './backends/AbstractAdapter';
+import { User } from './components/User';
 import { DataObjectClass } from './components/types/DataObjectClass';
-import { UserClass } from './components/types/UserClass';
-export declare type BackendRegistry<T extends AbstractAdapter> = {
+export type BackendRegistry<T extends AbstractAdapter> = {
     [x: string]: T;
 };
 export declare class Core {
     static defaultBackend: string;
-    static currentUser: UserClass;
+    static currentUser: User;
     static classRegistry: {
         [key: string]: any;
     };

package/lib/backends/AbstractAdapter.d.ts

@@ -1,8 +1,10 @@
+import { BackendAction } from '../Backend';
 import { DataObjectClass } from '../components/types/DataObjectClass';
 import { Filter } from './Filter';
 import { Filters } from './Filters';
 import { Query } from './Query';
 import { SortAndLimit } from './SortAndLimit';
+import Middleware from './middlewares/Middleware';
 /**
  * Default interface for a backend record
  */
@@ -14,7 +16,7 @@ export interface BackendRecordType {
 /**
  * Backend Parameters acceptable keys
  */
-export declare type BackendParametersKeys = 'host' | 'alias' | 'mapping' | 'middlewares' | 'config' | 'fixtures' | 'softDelete' | 'debug';
+export type BackendParametersKeys = 'host' | 'alias' | 'mapping' | 'middlewares' | 'config' | 'fixtures' | 'softDelete' | 'debug';
 /**
  * Backend parameters interface
  */
@@ -24,7 +26,7 @@ export interface BackendParameters {
     mapping?: {
         [x: string]: any;
     };
-    middlewares?: any[];
+    middlewares?: Middleware[];
     config?: any;
     fixtures?: any;
     softDelete?: boolean;
@@ -37,17 +39,19 @@ export interface BackendInterface {
     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>[]>;
+    count(query: Query<any>): Promise<number>;
 }
-export declare abstract class AbstractAdapter {
+export declare abstract class AbstractAdapter implements BackendInterface {
     protected _alias: string;
     protected _params: BackendParameters;
-    protected _middlewares: any[];
+    protected _middlewares: Middleware[];
     constructor(params?: BackendParameters);
     setParam(key: BackendParametersKeys, value: any): void;
     getParam(key: BackendParametersKeys): any;
+    addMiddleware(middleware: Middleware): void;
     set alias(alias: string);
     get alias(): string;
-    getCollection(dao: DataObjectClass<any>): any;
+    getCollection(dao: DataObjectClass<any>): string | undefined;
     abstract create(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
     abstract read(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
     abstract update(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
@@ -59,7 +63,8 @@ export declare abstract class AbstractAdapter {
      * @returns Array
      */
     query(query: Query<any>): Promise<DataObjectClass<any>[]>;
+    count(query: Query<any>): Promise<number>;
     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>>;
+    executeMiddlewares(dataObject: DataObjectClass<any>, action: BackendAction): Promise<DataObjectClass<any>>;
 }

package/lib/backends/AbstractAdapter.js

@@ -24,6 +24,9 @@ class AbstractAdapter {
     getParam(key) {
         return this._params[key];
     }
+    addMiddleware(middleware) {
+        this._middlewares.push(middleware);
+    }
     set alias(alias) {
         this._alias = alias;
     }
@@ -31,7 +34,7 @@ class AbstractAdapter {
         return this._alias;
     }
     getCollection(dao) {
-        return dao.uri.class.COLLECTION || dao.uri.class.name.toLowerCase();
+        return dao.uri.collection; //|| dao.uri.class.name.toLowerCase() //class.COLLECTION
     }
     /**
      * Process Query instance and return result
@@ -43,14 +46,21 @@ class AbstractAdapter {
             return yield this.find(yield query.obj.daoFactory(), query.filters, query.sortAndLimit);
         });
     }
+    count(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.find(yield query.obj.daoFactory(), query.filters, undefined)).length;
+        });
+    }
     log(message) {
         if (this._params['debug'] === true) {
             console.log(message);
         }
     }
-    executeMiddlewares(dataObject) {
+    executeMiddlewares(dataObject, action) {
         return __awaiter(this, void 0, void 0, function* () {
-            this._middlewares.forEach((middleware) => __awaiter(this, void 0, void 0, function* () { return yield middleware.execute(dataObject); }));
+            for (const middleware of this._middlewares) {
+                yield middleware.execute(dataObject, action);
+            }
             return dataObject;
         });
     }

package/lib/backends/Filter.d.ts

@@ -1,6 +1,6 @@
-import { BaseObject } from '../components';
+import { BaseObjectCore } from '../components';
 import { FilterOperatorType } from './FilterOperators';
-export declare type FilterValueType<T extends BaseObject> = T | number | string | string[] | null;
+export type FilterValueType<T extends BaseObjectCore> = T | number | string | string[] | null;
 export interface FilterType {
     prop: string;
     operator: FilterOperatorType | undefined;

package/lib/backends/FilterOperators.d.ts

@@ -10,4 +10,4 @@ export declare enum FilterOperator {
     containsAll = 8,
     containsAny = 9
 }
-export declare type FilterOperatorType = 'equals' | 'notEquals' | 'greater' | 'greaterOrEquals' | 'lower' | 'lowerOrEquals' | 'contains' | 'notContains' | 'containsAll' | 'containsAny';
+export type FilterOperatorType = 'equals' | 'notEquals' | 'greater' | 'greaterOrEquals' | 'lower' | 'lowerOrEquals' | 'contains' | 'notContains' | 'containsAll' | 'containsAny';

package/lib/backends/FilterOperators.js

@@ -13,4 +13,4 @@ var FilterOperator;
     FilterOperator[FilterOperator["notContains"] = 7] = "notContains";
     FilterOperator[FilterOperator["containsAll"] = 8] = "containsAll";
     FilterOperator[FilterOperator["containsAny"] = 9] = "containsAny";
-})(FilterOperator = exports.FilterOperator || (exports.FilterOperator = {}));
+})(FilterOperator || (exports.FilterOperator = FilterOperator = {}));

package/lib/backends/MockAdapter.js

@@ -14,7 +14,7 @@ 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");
+const ResourcesErrors_1 = require("../common/ResourcesErrors");
 class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
     /**
      * Inject fixtures data to backend adapter
@@ -67,7 +67,8 @@ class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
                 const path = dataObject.path;
                 const data = MockAdapter._fixtures[path];
                 if (data === undefined) {
-                    reject(new NotFoundError_1.NotFoundError(`[Mock] No data for ${path}`));
+                    reject(new ResourcesErrors_1.NotFoundError(`[Mock] No data for ${path}`));
+                    return;
                 }
                 this.log(`[DAO] Populating ${dataObject.path}`);
                 resolve(yield dataObject.populate(data));
@@ -80,7 +81,7 @@ class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
                 const path = dataObject.path;
                 const data = MockAdapter._fixtures[path];
                 if (data === undefined) {
-                    reject(new NotFoundError_1.NotFoundError(`[Mock] No data for ${path}`));
+                    reject(new ResourcesErrors_1.NotFoundError(`[Mock] No data for ${path}`));
                 }
                 this.log(`[DAO] Updating ${dataObject.path}`);
                 MockAdapter._fixtures[path] = Object.assign(Object.assign({}, data), dataObject.toJSON());
@@ -94,7 +95,7 @@ class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
                 const path = dataObject.path;
                 const data = MockAdapter._fixtures[path];
                 if (data === undefined) {
-                    reject(new NotFoundError_1.NotFoundError(`[Mock] No data for ${path}`));
+                    reject(new ResourcesErrors_1.NotFoundError(`[Mock] No data for ${path}`));
                 }
                 delete MockAdapter._fixtures[dataObject.path];
                 dataObject.uri = new ObjectUri_1.ObjectUri();
@@ -126,8 +127,11 @@ class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
                         if (Array.isArray(filters)) {
                             filters.forEach((filter) => {
                                 const prop = dao.get(filter.prop);
+                                if (typeof prop === 'undefined') {
+                                    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 &&
@@ -144,6 +148,10 @@ class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
                                             return;
                                         }
                                     }
+                                    else if (val !== filter.value) {
+                                        keep = false;
+                                        return;
+                                    }
                                 }
                                 else {
                                     if (prop.val() !== filter.value) {

package/lib/backends/Query.d.ts

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

package/lib/backends/Query.js

@@ -23,7 +23,7 @@ var returnAs;
     returnAs["AS_OBJECTURIS"] = "objectUris";
     returnAs["AS_DATAOBJECTS"] = "dataObjects";
     returnAs["AS_INSTANCES"] = "classInstances";
-})(returnAs = exports.returnAs || (exports.returnAs = {}));
+})(returnAs || (exports.returnAs = returnAs = {}));
 class Query {
     constructor(obj, params = {}) {
         this._obj = obj;
@@ -72,18 +72,38 @@ class Query {
     get sortAndLimit() {
         return new SortAndLimit_1.SortAndLimit(this.sortings, this.limits);
     }
+    fetch(backend = Core_1.Core.getBackend()) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return backend.query(this);
+        });
+    }
+    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));
+        });
+    }
+    fetchAsInstances(backend = Core_1.Core.getBackend()) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.fetch(backend);
+            const instances = [];
+            for (const item of result) {
+                instances.push(this._obj.fromDataObject(item));
+            }
+            return instances;
+        });
+    }
     execute(as = returnAs.AS_DATAOBJECTS, backend = Core_1.Core.getBackend()) {
         return __awaiter(this, void 0, void 0, function* () {
+            //</any><Array<T2> | Array<DataObject> | Array<ObjectUri>> {
             try {
-                const result = yield backend.query(this);
                 switch (as) {
                     case exports.AS_DATAOBJECTS:
-                        return result;
+                        return yield this.fetch(backend);
                     case exports.AS_OBJECTURIS:
-                        return yield Promise.all(result.map((dao) => dao.uri));
+                        return yield this.fetchAsUri(backend);
                     case exports.AS_INSTANCES:
-                        //console.log(this._obj)
-                        return yield Promise.all(result.map((dao) => Reflect.construct(this._obj, [dao])));
+                        return yield this.fetchAsInstances(backend);
                     default:
                         throw new Error(`Unknown output mode`);
                 }

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

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

package/lib/backends/middlewares/InjectMetaMiddleware.js

@@ -1,30 +1,7 @@
 "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"));
+const Backend_1 = require("../../Backend");
 class InjectMetaMiddleware {
     constructor(params) {
         this._user = params.user;
@@ -32,15 +9,18 @@ class InjectMetaMiddleware {
     execute(dataObject, action) {
         switch (action) {
             // add properties existence validation
-            case actions.CREATE:
-                dataObject.set('createdBy', this._user);
+            case Backend_1.BackendAction.CREATE:
+                dataObject.set('createdBy', this._user.core.dataObject.uri);
                 dataObject.set('createdAt', Date.now());
-            case actions.UPDATE:
-                dataObject.set('updatedBy', this._user);
+                break;
+            case Backend_1.BackendAction.UPDATE:
+                dataObject.set('updatedBy', this._user.core.dataObject.uri);
                 dataObject.set('updatedAt', Date.now());
-            case actions.DELETE:
-                dataObject.set('deletedBy', this._user);
-                dataObject.set('deleteddAt', Date.now());
+                break;
+            case Backend_1.BackendAction.DELETE:
+                dataObject.set('deletedBy', this._user.core.dataObject.uri);
+                dataObject.set('deletedAt', Date.now());
+                break;
             default:
                 break;
         }

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

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

package/lib/common/ResourcesErrors.d.ts

@@ -0,0 +1,13 @@
+export declare class ResourceError extends Error {
+    constructor(message: string);
+}
+export declare class BadRequestError extends ResourceError {
+}
+export declare class UnauthorizedError extends ResourceError {
+}
+export declare class ForbiddenError extends ResourceError {
+}
+export declare class NotFoundError extends ResourceError {
+}
+export declare class GoneError extends ResourceError {
+}

package/lib/common/ResourcesErrors.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoneError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BadRequestError = exports.ResourceError = void 0;
+class ResourceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+exports.ResourceError = ResourceError;
+class BadRequestError extends ResourceError {
+}
+exports.BadRequestError = BadRequestError;
+class UnauthorizedError extends ResourceError {
+}
+exports.UnauthorizedError = UnauthorizedError;
+class ForbiddenError extends ResourceError {
+}
+exports.ForbiddenError = ForbiddenError;
+class NotFoundError extends ResourceError {
+}
+exports.NotFoundError = NotFoundError;
+class GoneError extends ResourceError {
+}
+exports.GoneError = GoneError;

package/lib/components/AbstractObject.d.ts

@@ -1,6 +1,5 @@
 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 | undefined;
@@ -22,5 +21,4 @@ export declare abstract class AbstractObject {
     };
     save(): Promise<this>;
     delete(): Promise<DataObjectClass<any>>;
-    static query(): Query<typeof AbstractObject>;
 }

package/lib/components/AbstractObject.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractObject = void 0;
-const Query_1 = require("../backends/Query");
 class AbstractObject {
     constructor(dao) {
         this._dataObject = dao;
@@ -60,9 +59,6 @@ class AbstractObject {
             return yield this._dataObject.delete();
         });
     }
-    static query() {
-        return new Query_1.Query(this);
-    }
 }
 exports.AbstractObject = AbstractObject;
 AbstractObject.PROPS_DEFINITION = [];

package/lib/components/BaseObject.d.ts

@@ -1,15 +1,13 @@
 import { ObjectUri } from './ObjectUri';
-import { DataObjectClass } from './types/DataObjectClass';
-import { BaseObjectClass } from './types/BaseObjectClass';
-import { AbstractObject } from './AbstractObject';
-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 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>;
+import { User } from './User';
+export interface BaseObject {
+    name: string;
+    status: string;
+    createdBy?: User | ObjectUri;
+    createdAt?: number;
+    updatedBy?: User | ObjectUri;
+    updatedAt?: number;
+    deletedBy?: User | ObjectUri;
+    deletedAt?: number;
 }
+export declare const BaseObjectProperties: any;