@quatrain/core 1.0.0-beta1 → 1.0.0-beta2

package/lib/Backend.d.ts

@@ -1,6 +1,34 @@
+import Middleware from "./backends/middlewares/Middleware";
 export declare enum BackendAction {
     CREATE = "create",
     READ = "read",
     UPDATE = "update",
     DELETE = "delete"
 }
+/**
+ * Default interface for a backend record
+ */
+export interface BackendRecordType {
+    uid: string | undefined;
+    path: string | undefined;
+    [key: string]: any;
+}
+/**
+ * Backend Parameters acceptable keys
+ */
+export type BackendParametersKeys = 'host' | 'alias' | 'mapping' | 'middlewares' | 'config' | 'fixtures' | 'softDelete' | 'debug';
+/**
+ * Backend parameters interface
+ */
+export interface BackendParameters {
+    host?: string;
+    alias?: string;
+    mapping?: {
+        [x: string]: any;
+    };
+    middlewares?: Middleware[];
+    config?: any;
+    fixtures?: any;
+    softDelete?: boolean;
+    debug?: boolean;
+}

package/lib/Core.d.ts

@@ -1,19 +1,16 @@
 import { AbstractAdapter } from './backends/AbstractAdapter';
-import { User } from './components/User';
+import { UserCore } from './components/User';
 import { DataObjectClass } from './components/types/DataObjectClass';
 export type BackendRegistry<T extends AbstractAdapter> = {
     [x: string]: T;
 };
 export declare class Core {
     static defaultBackend: string;
-    static currentUser: User;
+    static userClass: typeof UserCore;
     static classRegistry: {
         [key: string]: any;
     };
-    static logger: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
+    static logger: Console;
     static timestamp: () => string;
     protected static _backends: BackendRegistry<any>;
     static definition(key: string): {
@@ -35,9 +32,8 @@ export declare class Core {
     /**
      * Log message using defined logger
      * This is currently just a stub that will be implemented from config in the future
-     * @param message string
+     * @param message string | object
      * @param level string
      */
-    static log(message: string, src?: string, level?: string): void;
-    static getObject(): void;
+    static log(message: any, src?: string, level?: string): void;
 }

package/lib/Core.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Core = void 0;
 const DataObject_1 = require("./components/DataObject");
+const User_1 = require("./components/User");
 class Core {
     static definition(key) {
         return {
@@ -42,18 +43,18 @@ class Core {
     /**
      * Log message using defined logger
      * This is currently just a stub that will be implemented from config in the future
-     * @param message string
+     * @param message string | object
      * @param level string
      */
     static log(message, src = 'Core', level = 'NOTICE') {
-        Core.logger(`${Date.now()} - [${src}] ${message}`);
+        Core.logger.log(`${Date.now()} - [${src}] ${typeof message === 'string' ? message : JSON.stringify(message)}`);
     }
-    static getObject() { }
 }
 exports.Core = Core;
 Core.defaultBackend = '@default';
+Core.userClass = User_1.UserCore;
 Core.classRegistry = {};
-Core.logger = console.log;
+Core.logger = console;
 // How timestamp are formatted
-Core.timestamp = () => (new Date().toISOString());
+Core.timestamp = () => new Date().toISOString();
 Core._backends = {};

package/lib/backends/AbstractAdapter.d.ts

@@ -1,46 +1,11 @@
-import { BackendAction } from '../Backend';
+import { BackendAction, BackendParameters, BackendParametersKeys } from '../Backend';
 import { DataObjectClass } from '../components/types/DataObjectClass';
+import { BackendInterface } from './types/BackendInterface';
 import { Filter } from './Filter';
 import { Filters } from './Filters';
-import { Query } from './Query';
+import { Query, QueryResultType } from './Query';
 import { SortAndLimit } from './SortAndLimit';
 import Middleware from './middlewares/Middleware';
-/**
- * Default interface for a backend record
- */
-export interface BackendRecordType {
-    uid: string | undefined;
-    path: string | undefined;
-    [key: string]: any;
-}
-/**
- * Backend Parameters acceptable keys
- */
-export type BackendParametersKeys = 'host' | 'alias' | 'mapping' | 'middlewares' | 'config' | 'fixtures' | 'softDelete' | 'debug';
-/**
- * Backend parameters interface
- */
-export interface BackendParameters {
-    host?: string;
-    alias?: string;
-    mapping?: {
-        [x: string]: any;
-    };
-    middlewares?: Middleware[];
-    config?: any;
-    fixtures?: any;
-    softDelete?: boolean;
-    debug?: boolean;
-}
-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>[]>;
-    count(query: Query<any>): Promise<number>;
-}
 export declare abstract class AbstractAdapter implements BackendInterface {
     protected _alias: string;
     protected _params: BackendParameters;
@@ -62,9 +27,8 @@ export declare abstract class AbstractAdapter implements BackendInterface {
      * @param query
      * @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>[]>;
+    query(query: Query<any>): Promise<QueryResultType<DataObjectClass<any>>>;
+    abstract find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined): Promise<QueryResultType<any>>;
     log(message: string): void;
     executeMiddlewares(dataObject: DataObjectClass<any>, action: BackendAction): Promise<DataObjectClass<any>>;
 }

package/lib/backends/AbstractAdapter.js

@@ -46,11 +46,6 @@ 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);

package/lib/backends/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): Promise<QueryResultType<DataObjectClass<any>>>;
+}

package/lib/backends/BackendInterface.js

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

package/lib/backends/MockAdapter.d.ts

@@ -1,9 +1,11 @@
-import { AbstractAdapter, BackendInterface } from './AbstractAdapter';
-import { BackendRecordType } from './AbstractAdapter';
+import { DataObjectClass } from '../components/types/DataObjectClass';
+import { QueryResultType } from './Query';
 import { Filter } from './Filter';
 import { Filters } from './Filters';
 import { SortAndLimit } from './SortAndLimit';
-import { DataObjectClass } from '../components/types/DataObjectClass';
+import { AbstractAdapter } from './AbstractAdapter';
+import { BackendInterface } from './types/BackendInterface';
+import { BackendRecordType } from '../Backend';
 export declare class MockAdapter extends AbstractAdapter implements BackendInterface {
     protected static _fixtures: any;
     /**
@@ -19,5 +21,5 @@ export declare class MockAdapter extends AbstractAdapter implements BackendInter
     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>[]>;
+    find(dataObject: DataObjectClass<any>, filters?: Filters | Filter[] | undefined, pagination?: SortAndLimit | undefined): Promise<QueryResultType<DataObjectClass<any>>>;
 }

package/lib/backends/MockAdapter.js

@@ -10,11 +10,12 @@ 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 Core_1 = require("../Core");
 const ObjectUri_1 = require("../components/ObjectUri");
 const faker_1 = require("@faker-js/faker");
 const BackendError_1 = require("./BackendError");
 const ResourcesErrors_1 = require("../common/ResourcesErrors");
+const AbstractAdapter_1 = require("./AbstractAdapter");
 class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
     /**
      * Inject fixtures data to backend adapter
@@ -116,12 +117,12 @@ class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
     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 = [];
+            let items = [];
             const collection = this.getCollection(dataObject);
             // TODO filter only records matchinf collection
             for (let key in MockAdapter.getFixtures()) {
                 let keep = true;
-                if (key.startsWith(`${collection}/`) && result.length <= limit) {
+                if (key.startsWith(`${collection}/`) && items.length <= limit) {
                     const dao = yield dataObject.clone(MockAdapter.getFixture(key));
                     if (filters) {
                         if (Array.isArray(filters)) {
@@ -164,15 +165,23 @@ class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
                     }
                     if (keep) {
                         dao.uri = new ObjectUri_1.ObjectUri(key);
-                        result.push(dao);
+                        items.push(dao);
                     }
                 }
             }
             if (pagination && pagination.sortings.length > 0) {
-                result = result.sort((a, b) => Number(a.val(pagination.sortings[0].prop) >
+                items = items.sort((a, b) => Number(a.val(pagination.sortings[0].prop) >
                     b.val(pagination.sortings[0].prop)));
             }
-            return result;
+            return {
+                items,
+                meta: {
+                    count: 100,
+                    offset: (pagination === null || pagination === void 0 ? void 0 : pagination.limits.offset) || 0,
+                    batch: (pagination === null || pagination === void 0 ? void 0 : pagination.limits.batch) || 10,
+                    executionTime: Core_1.Core.timestamp(),
+                },
+            };
         });
     }
 }

package/lib/backends/Query.d.ts

@@ -2,14 +2,24 @@ import { Filter } from './Filter';
 import { Limits } from './Limits';
 import { Sorting } from './Sorting';
 import { SortAndLimit } from './SortAndLimit';
-import { BackendInterface } from './AbstractAdapter';
+import { BackendInterface } from './types/BackendInterface';
 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";
+export type QueryMetaType = {
+    count: number;
+    offset: number;
+    batch: number;
+    executionTime: string | number;
+    sortField?: string;
+    sortOrder?: 'asc' | 'desc';
+};
+export type QueryResultType<T> = {
+    items: Array<T>;
+    meta: QueryMetaType;
+};
 export declare enum returnAs {
     AS_OBJECTURIS = "objectUris",
     AS_DATAOBJECTS = "dataObjects",
@@ -22,6 +32,7 @@ export declare class Query<T extends typeof BaseObjectCore> {
     filters: Filter[];
     sortings: Sorting[];
     limits: Limits;
+    meta: any;
     constructor(obj: T, params?: {
         [x: string]: any;
     });
@@ -32,8 +43,8 @@ export declare class Query<T extends typeof BaseObjectCore> {
     offset(offset?: number): this;
     batch(batch?: number): this;
     get sortAndLimit(): SortAndLimit;
-    fetch(backend?: BackendInterface): Promise<DataObjectClass<any>[]>;
-    fetchAsUri(backend?: BackendInterface): Promise<ObjectUri[]>;
-    fetchAsInstances(backend?: BackendInterface): Promise<Persisted<BaseObject>[]>;
-    execute(as?: returnAs, backend?: BackendInterface): Promise<any[]>;
+    fetch(backend?: BackendInterface): Promise<QueryResultType<DataObjectClass<any>>>;
+    fetchAsUri(backend?: BackendInterface): Promise<QueryResultType<ObjectUri>>;
+    fetchAsInstances(backend?: BackendInterface): Promise<QueryResultType<T>>;
+    execute(as?: returnAs, backend?: BackendInterface): Promise<QueryResultType<any>>;
 }

package/lib/backends/Query.js

@@ -32,18 +32,20 @@ class Query {
         this.filters = [];
         this.sortings = [];
         this.limits = new Limits_1.Limits();
+        this.meta = {};
     }
     get obj() {
         return this._obj;
     }
     where(param, value = null, operator = 'equals') {
+        console.log(`received value`, value);
         if (typeof param == 'object') {
             this.filters.push(param);
         }
         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));
         }
@@ -80,18 +82,18 @@ 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()) {

package/lib/backends/index.d.ts

@@ -1,10 +1,11 @@
-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 { 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, };

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

@@ -0,0 +1,9 @@
+import { DataObjectClass } from '../../components';
+import { BackendAction } from '../../Backend';
+import Middleware from './Middleware';
+export interface InjectKeywordsMiddlewareParams {
+}
+export declare class InjectKeywordsMiddleware implements Middleware {
+    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 copy.d.ts

@@ -0,0 +1,12 @@
+import { DataObjectClass } from '../../components';
+import { BackendAction } from '../../Backend';
+import { UserCore } from '../../components/User';
+import Middleware from './Middleware';
+export interface InjectMetaMiddlewareParams {
+    user: UserCore;
+}
+export declare class InjectMetaMiddleware implements Middleware {
+    protected _user: UserCore;
+    constructor(params: InjectMetaMiddlewareParams);
+    execute(dataObject: DataObjectClass<any>, action: BackendAction): void;
+}

package/lib/backends/middlewares/InjectMetaMiddleware copy.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectMetaMiddleware = void 0;
+const Backend_1 = require("../../Backend");
+class InjectMetaMiddleware {
+    constructor(params) {
+        this._user = params.user;
+    }
+    execute(dataObject, action) {
+        switch (action) {
+            // add properties existence validation
+            case Backend_1.BackendAction.CREATE:
+                dataObject.set('createdBy', this._user);
+                dataObject.set('createdAt', Date.now());
+                break;
+            case Backend_1.BackendAction.UPDATE:
+                dataObject.set('updatedBy', this._user);
+                dataObject.set('updatedAt', Date.now());
+                break;
+            case Backend_1.BackendAction.DELETE:
+                dataObject.set('deletedBy', this._user);
+                dataObject.set('deletedAt', Date.now());
+                break;
+            default:
+                break;
+        }
+        return;
+    }
+}
+exports.InjectMetaMiddleware = InjectMetaMiddleware;

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): Promise<QueryResultType<DataObjectClass<any>>>;
+}

package/lib/backends/types/BackendInterface.js

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

package/lib/common/statuses.d.ts

@@ -2,11 +2,13 @@ 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,15 +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.QUEUED = 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/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/BaseObjectCore.js

@@ -63,7 +63,7 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
         dao.uri.class = child;
         dao.populateFromData(src);
         const obj = new this(dao);
-        return obj; //.toProxy() as Proxy<T>
+        return obj;
     }
     static factory(src = undefined, child = this) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -144,7 +144,6 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
         });
     }
     asReference() {
-        console.log(this._dataObject.toReference());
         return this._dataObject.toReference();
     }
     query() {

package/lib/components/BaseRepository.d.ts

@@ -1,11 +1,8 @@
-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 { 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
@@ -17,7 +14,11 @@ export default class BaseRepository<T extends BaseObject> {
     protected getDataObjectFromUid(uid: string): Promise<DataObjectClass<any>>;
     create<B extends BaseObjectCore>(obj: B, uid?: string): Promise<any>;
     read(key: string): Promise<any>;
-    update(obj: Proxy<T>): Promise<Persisted<T>>;
-    delete(uid: string): Promise<void>;
-    query(query: Query<typeof BaseObjectCore>): Promise<Payload<Persisted<T>>>;
+    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

@@ -90,27 +90,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);
         });
     }
+    /**
+     * 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);
         });
     }
 }

package/lib/components/DataObject.d.ts

@@ -43,6 +43,7 @@ export declare class DataObject implements DataObjectClass<any> {
      */
     asProxy(): this;
     setProperties(properties: Properties): void;
+    addProperty(property: PropertyClassType): void;
     /**
      * Populate data object from instant data or backend query
      * @param data

package/lib/components/DataObject.js

@@ -13,6 +13,7 @@ exports.DataObject = void 0;
 const Core_1 = require("../Core");
 const Property_1 = require("../properties/Property");
 const ObjectUri_1 = require("./ObjectUri");
+const ResourcesErrors_1 = require("../common/ResourcesErrors");
 /**
  * Data objects constitute the agnostic glue between objects and backends.
  * They handle data and identifiers in a protected registry
@@ -74,6 +75,12 @@ class DataObject {
         // TODO check if doable
         this._properties = properties;
     }
+    addProperty(property) {
+        if (Object.keys(this._properties).includes(property.name)) {
+            throw new Error(`Property ${name} already exists`);
+        }
+        this._properties[property.name] = property;
+    }
     /**
      * Populate data object from instant data or backend query
      * @param data
@@ -192,12 +199,10 @@ class DataObject {
      * @returns BaseProperty
      */
     get(key) {
-        try {
-            return this._properties[key];
-        }
-        catch (err) {
-            throw new Error(err.message);
+        if (!Reflect.has(this._properties, key)) {
+            throw new ResourcesErrors_1.NotFoundError(`No property matching key ${key}`);
         }
+        return Reflect.get(this._properties, key);
     }
     set(key, val) {
         if (!this.has(key)) {
@@ -222,7 +227,7 @@ class DataObject {
         }
     }
     toJSON(objectsAsReferences = false) {
-        return Object.assign(Object.assign({}, (this._uid && { uid: this._uid })), this._dataToJSON(objectsAsReferences));
+        return Object.assign(Object.assign({}, (this.uri && { uid: this.uri.uid, path: this.uri.path })), this._dataToJSON(objectsAsReferences));
     }
     toReference() {
         return Object.assign(Object.assign({}, this._objectUri.toReference()), { label: this.val('name') || '' });

package/lib/components/Entity.d.ts

@@ -1,6 +1,6 @@
 import { BaseObjectCore } from './BaseObjectCore';
 import { BaseObject } from './BaseObject';
-import { User, UserCore } from './User';
+import { User } from './User';
 import { EntityClass } from './types/EntityClass';
 export declare const EntityProperties: any;
 export interface Entity extends BaseObject {
@@ -8,19 +8,5 @@ export interface Entity extends BaseObject {
 }
 export declare class EntityCore extends BaseObjectCore implements EntityClass {
     static COLLECTION: string;
-    static PROPS_DEFINITION: ({
-        name: string;
-        type: string;
-        mandatory: boolean;
-        minLength: number;
-        instanceOf?: undefined;
-        parentKey?: undefined;
-    } | {
-        name: string;
-        mandatory: boolean;
-        type: string;
-        instanceOf: typeof UserCore;
-        parentKey: string;
-        minLength?: undefined;
-    })[];
+    static PROPS_DEFINITION: any[];
 }

package/lib/components/Entity.js

@@ -25,6 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityCore = exports.EntityProperties = void 0;
 const BaseObjectCore_1 = require("./BaseObjectCore");
+const BaseObject_1 = require("./BaseObject");
 const User_1 = require("./User");
 const CollectionProperty_1 = require("../properties/CollectionProperty");
 const StringProperty_1 = require("../properties/StringProperty");
@@ -49,15 +50,16 @@ exports.EntityProperties = [
 class EntityCore extends BaseObjectCore_1.BaseObjectCore {
 }
 exports.EntityCore = EntityCore;
-EntityCore.COLLECTION = 'entity';
+EntityCore.COLLECTION = 'entities';
 EntityCore.PROPS_DEFINITION = [
+    ...BaseObject_1.BaseObjectProperties,
     {
         // surcharge property minLength and htmlType
         name: 'name',
         type: StringProperty_1.StringProperty.TYPE,
         mandatory: true,
         minLength: 1,
-        //htmlType: htmlType.ORG,
+        htmlType: htmlType.ORG,
     },
     {
         name: 'users',

package/lib/components/EntityRepository.d.ts

@@ -1,4 +1,4 @@
-import { BackendInterface } from '../backends';
+import { BackendInterface } from '../backends/types/BackendInterface';
 import BaseRepository from './BaseRepository';
 import { Entity } from './Entity';
 export default class EntityRepository extends BaseRepository<Entity> {

package/lib/components/User.d.ts

@@ -1,8 +1,7 @@
 import { BaseObjectCore } from './BaseObjectCore';
 import { BaseObject } from './BaseObject';
-import { Persisted } from './types/Persisted';
-import { Proxy } from './types/ProxyConstructor';
 export interface User extends BaseObject {
+    name: string;
     firstname: string;
     lastname: string;
     gender?: 'male' | 'female' | 'nonbinary';
@@ -14,5 +13,5 @@ export declare const UserProperties: any;
 export declare class UserCore extends BaseObjectCore {
     static PROPS_DEFINITION: any;
     static COLLECTION: string;
-    static factory(src?: any): Promise<Proxy<User> | Persisted<User>>;
+    static factory(src?: any): Promise<UserCore>;
 }

package/lib/components/User.js

@@ -39,6 +39,7 @@ const HashProperty_1 = require("../properties/HashProperty");
 const StringProperty_1 = require("../properties/StringProperty");
 const htmlType = __importStar(require("../properties/types/PropertyHTMLType"));
 const BaseObject_1 = require("./BaseObject");
+const Entity_1 = require("./Entity");
 /**
  * Callback function to populate the 'name' property
  * @param dao DataObject
@@ -52,7 +53,6 @@ exports.UserProperties = [
         name: 'name',
         type: StringProperty_1.StringProperty.TYPE,
         minLength: 0,
-        fullSearch: true,
         htmlType: htmlType.NAME,
     },
     {
@@ -61,6 +61,7 @@ exports.UserProperties = [
         type: StringProperty_1.StringProperty.TYPE,
         minLength: 1,
         maxLength: 100,
+        fullSearch: true,
         htmlType: htmlType.GIVEN_NAME,
         onChange,
     },
@@ -70,6 +71,7 @@ exports.UserProperties = [
         type: StringProperty_1.StringProperty.TYPE,
         minLength: 1,
         maxLength: 100,
+        fullSearch: true,
         htmlType: htmlType.FAMILY_NAME,
         onChange,
     },
@@ -109,7 +111,7 @@ exports.UserProperties = [
         name: 'entity',
         mandatory: false,
         type: properties_1.ObjectProperty.TYPE,
-        instanceOf: BaseObjectCore_1.BaseObjectCore,
+        instanceOf: Entity_1.EntityCore,
     },
 ];
 class UserCore extends BaseObjectCore_1.BaseObjectCore {

package/lib/components/UserRepository.d.ts

@@ -1,7 +1,7 @@
-import { BackendInterface } from '../backends';
+import { BackendInterface } from '../backends/types/BackendInterface';
 import BaseRepository from './BaseRepository';
 import { User } from './User';
 export default class UserRepository extends BaseRepository<User> {
     constructor(backendAdapter?: BackendInterface);
-    getFromEmail(email: string): Promise<import("./types/Persisted").Persisted<import("./types/Persisted").Persisted<User>>>;
+    getFromEmail(email: string): Promise<User>;
 }

package/lib/components/types/DataObjectClass.d.ts

@@ -1,3 +1,4 @@
+import { PropertyClassType } from '../../properties/types/PropertyClassType';
 import { ObjectUri } from '../ObjectUri';
 export interface DataObjectClass<T extends DataObjectClass<any>> {
     uri: ObjectUri;
@@ -7,6 +8,7 @@ export interface DataObjectClass<T extends DataObjectClass<any>> {
     class: any;
     properties: any;
     setProperties(properties: any): void;
+    addProperty(property: PropertyClassType): void;
     populate(data?: any): Promise<T>;
     isPopulated(): boolean;
     isPersisted(): boolean;

package/lib/components/types/RepositoryClass.d.ts

@@ -1,4 +1,4 @@
-import { BackendInterface } from '../../backends/AbstractAdapter';
+import { BackendInterface } from '../../backends/types/BackendInterface';
 import { Query } from '../../backends/Query';
 import { BaseObjectCore } from '../BaseObjectCore';
 import { BaseObject } from '../BaseObject';

package/lib/index.d.ts

@@ -17,13 +17,15 @@ import { BaseObjectCore } from './components/BaseObjectCore';
 import { BaseObject, BaseObjectProperties } from './components/BaseObject';
 import { Proxy } from './components/types/ProxyConstructor';
 import { InjectMetaMiddleware } from './backends/middlewares/InjectMetaMiddleware';
+import { InjectKeywordsMiddleware } from './backends/middlewares/InjectKeywordsMiddleware';
 import RepositoryClass from './components/types/RepositoryClass';
 import BaseRepository from './components/BaseRepository';
+import { BackendAction, BackendParameters, BackendParametersKeys, BackendRecordType } from './Backend';
 import Middleware from './backends/middlewares/Middleware';
 import { User } from './components/User';
 import UserRepository from './components/UserRepository';
 import { Entity } from './components/Entity';
 import EntityRepository from './components/EntityRepository';
-import { AbstractAdapter, MockAdapter, BackendError, BackendParameters, Query, Filter, Filters, Limits, Sorting, SortAndLimit } from './backends';
+import { AbstractAdapter, MockAdapter, BackendError, Query, QueryMetaType, QueryResultType, Filter, Filters, Limits, Sorting, SortAndLimit } from './backends';
 import { BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, GoneError } from './common/ResourcesErrors';
-export { statuses, utils, Core, Property, BaseProperty, BasePropertyType, BooleanProperty, BooleanPropertyType, DateTimeProperty, DateTimePropertyType, EnumProperty, EnumPropertyType, HashProperty, HashPropertyType, ObjectProperty, ObjectPropertyType, StringProperty, StringPropertyType, AbstractAdapter, RepositoryClass, MockAdapter, ObjectUri, DataObjectClass, DataObject, AbstractObject, BaseObject, BaseObjectCore, BaseObjectProperties, BackendParameters, BaseRepository, BackendError, Query, Filter, Filters, Limits, Sorting, SortAndLimit, Middleware, InjectMetaMiddleware, User, Proxy, UserRepository, Entity, EntityRepository, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, GoneError, };
+export { statuses, utils, Core, Property, BaseProperty, BasePropertyType, BooleanProperty, BooleanPropertyType, DateTimeProperty, DateTimePropertyType, EnumProperty, EnumPropertyType, HashProperty, HashPropertyType, ObjectProperty, ObjectPropertyType, StringProperty, StringPropertyType, AbstractAdapter, RepositoryClass, MockAdapter, ObjectUri, DataObjectClass, DataObject, AbstractObject, BaseObject, BaseObjectCore, BaseObjectProperties, BackendParameters, BackendParametersKeys, BackendRecordType, BackendAction, BaseRepository, BackendError, Query, QueryMetaType, QueryResultType, Filter, Filters, Limits, Sorting, SortAndLimit, Middleware, InjectMetaMiddleware, InjectKeywordsMiddleware, User, Proxy, UserRepository, Entity, EntityRepository, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, GoneError, };

package/lib/index.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GoneError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BadRequestError = exports.EntityRepository = exports.UserRepository = exports.InjectMetaMiddleware = exports.SortAndLimit = exports.Sorting = exports.Limits = exports.Filters = exports.Filter = exports.Query = exports.BackendError = exports.BaseRepository = exports.BaseObjectProperties = exports.BaseObjectCore = exports.AbstractObject = exports.DataObject = exports.ObjectUri = exports.MockAdapter = exports.AbstractAdapter = exports.StringProperty = exports.ObjectProperty = exports.HashProperty = exports.EnumProperty = exports.DateTimeProperty = exports.BooleanProperty = exports.BaseProperty = exports.Property = exports.Core = exports.utils = exports.statuses = void 0;
+exports.GoneError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BadRequestError = exports.EntityRepository = exports.UserRepository = exports.InjectKeywordsMiddleware = exports.InjectMetaMiddleware = exports.SortAndLimit = exports.Sorting = exports.Limits = exports.Filters = exports.Filter = exports.Query = exports.BackendError = exports.BaseRepository = exports.BackendAction = exports.BaseObjectProperties = exports.BaseObjectCore = exports.AbstractObject = exports.DataObject = exports.ObjectUri = exports.MockAdapter = exports.AbstractAdapter = exports.StringProperty = exports.ObjectProperty = exports.HashProperty = exports.EnumProperty = exports.DateTimeProperty = exports.BooleanProperty = exports.BaseProperty = exports.Property = exports.Core = exports.utils = exports.statuses = void 0;
 const Core_1 = require("./Core");
 Object.defineProperty(exports, "Core", { enumerable: true, get: function () { return Core_1.Core; } });
 const statuses = __importStar(require("./common/statuses"));
@@ -61,8 +61,12 @@ const BaseObject_1 = require("./components/BaseObject");
 Object.defineProperty(exports, "BaseObjectProperties", { enumerable: true, get: function () { return BaseObject_1.BaseObjectProperties; } });
 const InjectMetaMiddleware_1 = require("./backends/middlewares/InjectMetaMiddleware");
 Object.defineProperty(exports, "InjectMetaMiddleware", { enumerable: true, get: function () { return InjectMetaMiddleware_1.InjectMetaMiddleware; } });
+const InjectKeywordsMiddleware_1 = require("./backends/middlewares/InjectKeywordsMiddleware");
+Object.defineProperty(exports, "InjectKeywordsMiddleware", { enumerable: true, get: function () { return InjectKeywordsMiddleware_1.InjectKeywordsMiddleware; } });
 const BaseRepository_1 = __importDefault(require("./components/BaseRepository"));
 exports.BaseRepository = BaseRepository_1.default;
+const Backend_1 = require("./Backend");
+Object.defineProperty(exports, "BackendAction", { enumerable: true, get: function () { return Backend_1.BackendAction; } });
 const UserRepository_1 = __importDefault(require("./components/UserRepository"));
 exports.UserRepository = UserRepository_1.default;
 const EntityRepository_1 = __importDefault(require("./components/EntityRepository"));

package/lib/properties/CollectionProperty.d.ts

@@ -1,5 +1,5 @@
 import { BaseProperty, BasePropertyType } from './BaseProperty';
-import { Query } from '../backends/Query';
+import { Query, QueryResultType } from '../backends/Query';
 import { Filter } from '../backends/Filter';
 import { ObjectUri } from '../components/ObjectUri';
 import { returnAs } from '../backends/Query';
@@ -28,6 +28,6 @@ export declare class CollectionProperty extends BaseProperty {
      * @returns
      */
     get(filters?: Filter[] | undefined): Query<any>;
-    val(transform?: returnAs): Promise<Array<any> | Array<DataObjectClass<any>> | Array<ObjectUri>>;
+    val(transform?: returnAs): Promise<QueryResultType<any>>;
     toJSON(): any[] | DataObjectClass<any>[] | ObjectUri[] | undefined;
 }

package/lib/properties/HashProperty.d.ts

@@ -16,6 +16,12 @@ export declare class HashProperty extends StringProperty {
     protected _prefixed: boolean;
     constructor(config: HashPropertyType);
     _hash(value: string): string;
+    /**
+     * Never return the password which is hashed anyway
+     * @param transform
+     * @returns
+     */
+    get(transform?: string | undefined): string | undefined;
     set(value: string): this;
     compare(value: string): boolean;
 }

package/lib/properties/HashProperty.js

@@ -34,6 +34,14 @@ class HashProperty extends StringProperty_1.StringProperty {
         this._rawValue = false; // don't test some constraints after hashing
         return hash;
     }
+    /**
+     * Never return the password which is hashed anyway
+     * @param transform
+     * @returns
+     */
+    get(transform) {
+        return;
+    }
     set(value) {
         return super.set(this._hash(value));
     }

package/lib/properties/types/PropertyClassType.d.ts

@@ -1,5 +1,6 @@
 import { AbstractPropertyType } from './AbstractPropertyType';
 export interface PropertyClassType {
+    name: string;
     set(value: any): AbstractPropertyType;
     val(transform?: any): any;
     toJSON(): any;

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@quatrain/core",
-   "version": "1.0.0-beta1",
+   "version": "1.0.0-beta2",
    "description": "Core objects for business apps",
    "main": "lib/index.js",
    "types": "lib/index.d.ts",