@quatrain/core 1.0.0-beta3 → 1.0.0-beta4

package/lib/Backend.d.ts

@@ -1,4 +1,4 @@
-import Middleware from "./backends/middlewares/Middleware";
+import Middleware from './backends/middlewares/Middleware';
 export declare enum BackendAction {
     CREATE = "create",
     READ = "read",
@@ -23,6 +23,9 @@ export type BackendParametersKeys = 'host' | 'alias' | 'mapping' | 'middlewares'
 export interface BackendParameters {
     host?: string;
     alias?: string;
+    hierarchy?: {
+        [collection: string]: any;
+    };
     mapping?: {
         [x: string]: any;
     };

package/lib/backends/AbstractAdapter.d.ts

@@ -34,7 +34,7 @@ export declare abstract class AbstractAdapter implements BackendInterface {
      * @returns Array
      */
     query(query: Query<any>): Promise<QueryResultType<DataObjectClass<any>>>;
-    abstract find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined): Promise<QueryResultType<any>>;
+    abstract find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined, parent: any): Promise<QueryResultType<any>>;
     log(message: string): void;
     executeMiddlewares(dataObject: DataObjectClass<any>, action: BackendAction): Promise<DataObjectClass<any>>;
 }

package/lib/backends/AbstractAdapter.js

@@ -52,7 +52,7 @@ class AbstractAdapter {
         return this._alias;
     }
     getCollection(dao) {
-        return dao.uri.collection; //|| dao.uri.class.name.toLowerCase() //class.COLLECTION
+        return dao.uri.collection;
     }
     /**
      * Process Query instance and return result
@@ -61,7 +61,10 @@ class AbstractAdapter {
      */
     query(query) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.find(yield query.obj.daoFactory(), query.filters, query.sortAndLimit);
+            const dao = yield query.obj.daoFactory();
+            if (query.parent) {
+            }
+            return yield this.find(dao, query.filters, query.sortAndLimit, query.parent);
         });
     }
     log(message) {

package/lib/backends/Filters.d.ts

@@ -2,9 +2,10 @@ import { Filter } from './Filter';
 export interface FiltersType {
     or?: Filter[];
     and?: Filter[];
+    base?: string;
 }
 export declare class Filters implements FiltersType {
     or?: Filter[];
     and?: Filter[];
-    constructor(or: Filter[] | undefined, and: Filter[] | undefined);
+    constructor(or?: Filter[], and?: Filter[]);
 }

package/lib/backends/Query.d.ts

@@ -28,15 +28,19 @@ export declare enum returnAs {
 }
 export declare class Query<T extends typeof BaseObjectCore> {
     protected _obj: T;
-    protected _params: any;
+    protected _parent: T | undefined;
     filters: Filter[];
     sortings: Sorting[];
     limits: Limits;
     meta: any;
-    constructor(obj: T, params?: {
-        [x: string]: any;
-    });
+    constructor(obj: T, parent?: T | undefined);
     get obj(): T;
+    get parent(): T | undefined;
+    /**
+     * Declare query parent record
+     * This may be need in some NoSQL backend to query subcollections
+     */
+    set parent(parent: T);
     where(param: Filter | string, value?: any, operator?: any): this;
     sortBy(param: Sorting | string, order?: any): this;
     setLimits(limits: Limits): this;

package/lib/backends/Query.js

@@ -26,9 +26,9 @@ var returnAs;
     returnAs["AS_IS"] = "asIs";
 })(returnAs || (exports.returnAs = returnAs = {}));
 class Query {
-    constructor(obj, params = {}) {
+    constructor(obj, parent = undefined) {
         this._obj = obj;
-        this._params = params; // just in case
+        this._parent = parent;
         this.filters = [];
         this.sortings = [];
         this.limits = new Limits_1.Limits();
@@ -37,8 +37,17 @@ class Query {
     get obj() {
         return this._obj;
     }
+    get parent() {
+        return this._parent;
+    }
+    /**
+     * Declare query parent record
+     * This may be need in some NoSQL backend to query subcollections
+     */
+    set parent(parent) {
+        this._parent = parent;
+    }
     where(param, value = null, operator = 'equals') {
-        console.log(`received value`, value);
         if (typeof param == 'object') {
             this.filters.push(param);
         }

package/lib/backends/index.d.ts

@@ -2,10 +2,11 @@ import { AbstractAdapter } from './AbstractAdapter';
 import { MockAdapter } from './MockAdapter';
 import { BackendError } from './BackendError';
 import { BackendInterface } from './types/BackendInterface';
+import * as BackendCollectionHierarchy from './types/BackendCollectionHierarchy';
 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 { BackendInterface, AbstractAdapter, BackendError, MockAdapter, Query, QueryResultType, QueryMetaType, Filter, Filters, Sorting, Limits, SortAndLimit, };
+export { BackendInterface, AbstractAdapter, BackendError, MockAdapter, Query, QueryResultType, QueryMetaType, Filter, Filters, Sorting, Limits, SortAndLimit, BackendCollectionHierarchy, };

package/lib/backends/index.js

@@ -1,12 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SortAndLimit = exports.Limits = exports.Sorting = exports.Filters = exports.Filter = exports.Query = exports.MockAdapter = exports.BackendError = exports.AbstractAdapter = void 0;
+exports.BackendCollectionHierarchy = exports.SortAndLimit = exports.Limits = exports.Sorting = exports.Filters = exports.Filter = exports.Query = exports.MockAdapter = exports.BackendError = exports.AbstractAdapter = void 0;
 const AbstractAdapter_1 = require("./AbstractAdapter");
 Object.defineProperty(exports, "AbstractAdapter", { enumerable: true, get: function () { return AbstractAdapter_1.AbstractAdapter; } });
 const MockAdapter_1 = require("./MockAdapter");
 Object.defineProperty(exports, "MockAdapter", { enumerable: true, get: function () { return MockAdapter_1.MockAdapter; } });
 const BackendError_1 = require("./BackendError");
 Object.defineProperty(exports, "BackendError", { enumerable: true, get: function () { return BackendError_1.BackendError; } });
+const BackendCollectionHierarchy = __importStar(require("./types/BackendCollectionHierarchy"));
+exports.BackendCollectionHierarchy = BackendCollectionHierarchy;
 const Query_1 = require("./Query");
 Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return Query_1.Query; } });
 const Filter_1 = require("./Filter");

package/lib/backends/types/BackendCollectionHierarchy.d.ts

@@ -0,0 +1,3 @@
+export declare const STANDARD = 1;
+export declare const SUBCOLLECTION = 2;
+export declare const SUBCOLLECTION_GROUP = 3;

package/lib/backends/types/BackendCollectionHierarchy.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBCOLLECTION_GROUP = exports.SUBCOLLECTION = exports.STANDARD = void 0;
+exports.STANDARD = 1;
+exports.SUBCOLLECTION = 2;
+exports.SUBCOLLECTION_GROUP = 3;

package/lib/backends/types/BackendInterface.d.ts

@@ -9,5 +9,5 @@ export interface BackendInterface {
     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>>>;
+    find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined, parent: any): Promise<QueryResultType<DataObjectClass<any>>>;
 }

package/lib/components/AbstractObject.d.ts

@@ -3,6 +3,7 @@ import { DataObjectProperties } from '../properties';
 export declare abstract class AbstractObject {
     static PROPS_DEFINITION: DataObjectProperties;
     static COLLECTION: string | undefined;
+    static PARENT_PROP: string | undefined;
     static LABEL_KEY: string;
     protected _dataObject: DataObjectClass<any>;
     constructor(dao: DataObjectClass<any>);

package/lib/components/BaseObjectCore.d.ts

@@ -59,6 +59,15 @@ export declare class BaseObjectCore extends AbstractObject implements BaseObject
      */
     protected toProxy<T extends BaseObject>(): Proxy<Proxy<T>>;
     asReference(): any;
-    query(): Query<any>;
+    /**
+     * Create a query based on given class where parent is current instance
+     * @param obj
+     * @returns Query
+     */
+    query(obj: any): Query<any>;
+    /**
+     * Create a query based on current class
+     * @returns Query
+     */
     static query(): Query<typeof BaseObjectCore>;
 }

package/lib/components/BaseObjectCore.js

@@ -146,9 +146,18 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
     asReference() {
         return this._dataObject.toReference();
     }
-    query() {
-        return new Query_1.Query(this.constructor.prototype);
+    /**
+     * Create a query based on given class where parent is current instance
+     * @param obj
+     * @returns Query
+     */
+    query(obj) {
+        return new Query_1.Query(obj, this);
     }
+    /**
+     * Create a query based on current class
+     * @returns Query
+     */
     static query() {
         return new Query_1.Query(this);
     }

package/lib/components/BaseRepository.d.ts

@@ -12,6 +12,7 @@ export default class BaseRepository<T extends BaseObject> {
     backendAdapter: BackendInterface;
     constructor(model: typeof BaseObjectCore, backendAdapter?: BackendInterface);
     protected getDataObjectFromUid(uid: string): Promise<DataObjectClass<any>>;
+    protected getDataObjectFromPath(path: string): Promise<DataObjectClass<any>>;
     create<B extends BaseObjectCore>(obj: B, uid?: string): Promise<any>;
     read(key: string): Promise<any>;
     update(obj: BaseObjectCore): Promise<any>;

package/lib/components/BaseRepository.js

@@ -58,17 +58,35 @@ class BaseRepository {
             return dataObject;
         });
     }
+    getDataObjectFromPath(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataObject = DataObject_1.DataObject.factory({
+                properties: this._model.PROPS_DEFINITION,
+                uri: path,
+            });
+            dataObject.uid = path.substring(path.lastIndexOf('/') + 1);
+            return dataObject;
+        });
+    }
     create(obj, uid) {
         return __awaiter(this, void 0, void 0, function* () {
             const savedObj = yield this.backendAdapter.create(obj.dataObject, uid);
-            return this._model.fromDataObject(savedObj); //as Persisted<T>
+            return this._model.fromDataObject(savedObj);
         });
     }
     read(key) {
         return __awaiter(this, void 0, void 0, function* () {
-            const uid = key.indexOf('/') !== -1 ? key.substring(key.lastIndexOf('/') + 1) : key;
             try {
-                const dataObject = yield this.getDataObjectFromUid(uid);
+                let dataObject;
+                if (key.split('/').length <= 2) {
+                    const uid = key.indexOf('/') !== -1
+                        ? key.substring(key.lastIndexOf('/') + 1)
+                        : key;
+                    dataObject = yield this.getDataObjectFromUid(uid);
+                }
+                else {
+                    dataObject = yield this.getDataObjectFromPath(key);
+                }
                 const response = yield this.backendAdapter.read(dataObject);
                 const obj = this._model.fromDataObject(response);
                 // TODO should be moved to the backend middleware

package/package.json

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