@quatrain/core 0.5.6 → 1.0.0-beta2

package/lib/components/UserProperties.js

@@ -0,0 +1,103 @@
+"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.UserProperties = void 0;
+const properties_1 = require("../properties");
+const HashProperty_1 = require("../properties/HashProperty");
+const StringProperty_1 = require("../properties/StringProperty");
+const Entity_1 = require("./Entity");
+const htmlType = __importStar(require("../properties/types/PropertyHTMLType"));
+/**
+ * Callback function to populate the 'name' property
+ * @param dao DataObject
+ * @returns
+ */
+const onChange = (dao) => dao.set('name', `${dao.val('firstname')} ${dao.val('lastname')}`);
+exports.UserProperties = [
+    {
+        // change name property minLength
+        name: 'name',
+        type: StringProperty_1.StringProperty.TYPE,
+        minLength: 0,
+        fullSearch: true,
+        htmlType: htmlType.NAME,
+    },
+    {
+        name: 'firstname',
+        mandatory: true,
+        type: StringProperty_1.StringProperty.TYPE,
+        minLength: 1,
+        maxLength: 100,
+        htmlType: htmlType.GIVEN_NAME,
+        onChange,
+    },
+    {
+        name: 'lastname',
+        mandatory: true,
+        type: StringProperty_1.StringProperty.TYPE,
+        minLength: 1,
+        maxLength: 100,
+        htmlType: htmlType.FAMILY_NAME,
+        onChange,
+    },
+    {
+        name: 'gender',
+        mandatory: false,
+        type: properties_1.EnumProperty.TYPE,
+        values: ['male', 'female', 'nonbinary'],
+        htmlType: htmlType.GENDER,
+    },
+    {
+        name: 'birthday',
+        mandatory: false,
+        type: properties_1.DateTimeProperty.TYPE,
+        htmlType: htmlType.BIRTHDAY,
+    },
+    {
+        name: 'email',
+        mandatory: true,
+        type: StringProperty_1.StringProperty.TYPE,
+        minLength: 1,
+        maxLength: 100,
+        fullSearch: true,
+        htmlType: htmlType.EMAIL,
+    },
+    {
+        name: 'password',
+        mandatory: true,
+        type: HashProperty_1.HashProperty.TYPE,
+        algorithm: HashProperty_1.HashProperty.ALGORITHM_SHA256,
+        salt: '',
+        minLength: 5,
+        maxLength: 20,
+        htmlType: htmlType.PASSWORD,
+    },
+    {
+        name: 'entity',
+        mandatory: false,
+        type: properties_1.ObjectProperty.TYPE,
+        instanceof: Entity_1.Entity,
+    },
+];

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

@@ -4,6 +4,7 @@ import { ObjectUri } from './ObjectUri';
 import { AbstractObject } from './AbstractObject';
 import { BaseObjectCore } from './BaseObjectCore';
 import { BaseObjectProperties } from './BaseObject';
+import BaseRepository from './BaseRepository';
 import { UserCore, UserProperties } from './User';
 import { Entity } from './Entity';
-export { DataObject, DataObjectParams, DataObjectClass, ObjectUri, AbstractObject, BaseObjectCore, UserCore, Entity, BaseObjectProperties, UserProperties, };
+export { DataObject, DataObjectParams, DataObjectClass, ObjectUri, AbstractObject, BaseObjectCore, BaseRepository, UserCore, Entity, BaseObjectProperties, UserProperties, };

package/lib/components/index.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserProperties = exports.BaseObjectProperties = exports.UserCore = exports.BaseObjectCore = exports.AbstractObject = exports.ObjectUri = exports.DataObject = void 0;
+exports.UserProperties = exports.BaseObjectProperties = exports.UserCore = exports.BaseRepository = exports.BaseObjectCore = exports.AbstractObject = exports.ObjectUri = exports.DataObject = void 0;
 const DataObject_1 = require("./DataObject");
 Object.defineProperty(exports, "DataObject", { enumerable: true, get: function () { return DataObject_1.DataObject; } });
 const ObjectUri_1 = require("./ObjectUri");
@@ -11,6 +14,8 @@ const BaseObjectCore_1 = require("./BaseObjectCore");
 Object.defineProperty(exports, "BaseObjectCore", { enumerable: true, get: function () { return BaseObjectCore_1.BaseObjectCore; } });
 const BaseObject_1 = require("./BaseObject");
 Object.defineProperty(exports, "BaseObjectProperties", { enumerable: true, get: function () { return BaseObject_1.BaseObjectProperties; } });
+const BaseRepository_1 = __importDefault(require("./BaseRepository"));
+exports.BaseRepository = BaseRepository_1.default;
 const User_1 = require("./User");
 Object.defineProperty(exports, "UserCore", { enumerable: true, get: function () { return User_1.UserCore; } });
 Object.defineProperty(exports, "UserProperties", { enumerable: true, get: function () { return User_1.UserProperties; } });

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;
@@ -23,4 +25,5 @@ export interface DataObjectClass<T extends DataObjectClass<any>> {
     populateFromData(data: {
         [x: string]: unknown;
     }): this;
+    asProxy(): any;
 }

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';
@@ -18,7 +18,7 @@ export default interface RepositoryClass<T extends BaseObject> {
      * @param uid
      * @returns
      */
-    read(uid: string): Promise<Persisted<T>>;
+    read(uid: string): Promise<any>;
     /**
      * Updates a given object in the collction and returns it
      * @param obj

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

@@ -0,0 +1,3 @@
+import { BaseObjectClass } from './BaseObjectClass';
+export interface UserClass extends BaseObjectClass {
+}

package/lib/components/types/UserClass.js

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

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 AbstractRepository from './components/BaseRepository';
+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, AbstractRepository, MockAdapter, ObjectUri, DataObjectClass, DataObject, AbstractObject, BaseObject, BaseObjectCore, BaseObjectProperties, BackendParameters, 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.BaseObjectProperties = exports.BaseObjectCore = exports.AbstractObject = exports.DataObject = exports.ObjectUri = exports.MockAdapter = exports.AbstractRepository = 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.AbstractRepository = BaseRepository_1.default;
+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/BaseProperty.js

@@ -52,7 +52,7 @@ class BaseProperty {
         return this;
     }
     val(transform = undefined) {
-        return transform ? transform(this._value) : this._value;
+        return transform ? transform(this._value) : this._value || this._defaultValue;
     }
     _enable(value) {
         return value === undefined || value === true;

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

@@ -1,15 +1,15 @@
-import { BaseObject } from '../components/BaseObject';
 import { ObjectUri } from '../components/ObjectUri';
 import { BaseProperty, BasePropertyType } from './BaseProperty';
-import { Proxy } from '../components/types/ProxyConstructor';
+import { BaseObjectClass } from '../components/types/BaseObjectClass';
 export interface ObjectPropertyType extends BasePropertyType {
-    instanceOf?: Function | string | Object;
+    instanceOf: any;
 }
 export declare class ObjectProperty extends BaseProperty {
     static TYPE: string;
-    _value: Proxy<BaseObject> | ObjectUri | undefined;
-    _instanceOf: Function | string | Object;
+    _value: BaseObjectClass | ObjectUri | undefined;
+    _instanceOf: any;
     constructor(config: ObjectPropertyType);
+    val(transform?: string | undefined): any;
     set(value: object): this;
     toJSON(): any;
 }

package/lib/properties/ObjectProperty.js

@@ -4,11 +4,64 @@ exports.ObjectProperty = void 0;
 const DataObject_1 = require("../components/DataObject");
 const ObjectUri_1 = require("../components/ObjectUri");
 const BaseProperty_1 = require("./BaseProperty");
+const Query_1 = require("../backends/Query");
+const Core_1 = require("../Core");
 class ObjectProperty extends BaseProperty_1.BaseProperty {
     constructor(config) {
         super(config);
         this._value = undefined;
-        this._instanceOf = config.instanceOf || Object;
+        this._instanceOf = config.instanceOf;
+    }
+    val(transform = undefined) {
+        if (typeof this._instanceOf === 'string') {
+            console.log(`Getting instance from string ${this._instanceOf}`);
+            this._instanceOf = Core_1.Core.getClass(this._instanceOf);
+            //throw new Error(`Parameter 'instanceOf' was not properly setted`)
+        }
+        if (!this._value) {
+            return this._defaultValue;
+        }
+        switch (transform) {
+            case Query_1.returnAs.AS_DATAOBJECTS:
+                if (this._value instanceof DataObject_1.DataObject) {
+                    console.log(`Returning already existing dataObject`);
+                    return this._value;
+                }
+                else if (this._value instanceof ObjectUri_1.ObjectUri) {
+                    console.log(`Converting objectUri -> dataObject`);
+                    return DataObject_1.DataObject.factory({
+                        properties: Reflect.get(this._instanceOf, 'PROPS_DEFINITION'),
+                        uri: this._value,
+                    });
+                }
+                else {
+                    console.log(`Converting instance -> dataObject`);
+                    return this._value.dataObject;
+                }
+            case Query_1.returnAs.AS_INSTANCES:
+                if (this._value instanceof DataObject_1.DataObject) {
+                    console.log(`Converting dataObject -> instance`);
+                    return Reflect.construct(this._instanceOf, [this._value]);
+                }
+                else if (this._value instanceof ObjectUri_1.ObjectUri) {
+                    console.log('ObjectProperty', this);
+                    console.log(`Converting objectUri -> dataObject -> instance`);
+                    console.log(this._instanceOf);
+                    const dao = DataObject_1.DataObject.factory({
+                        properties: Reflect.get(this._instanceOf, 'PROPS_DEFINITION'),
+                        uri: this._value,
+                    });
+                    return Reflect.construct(this._instanceOf, [dao]);
+                }
+                else {
+                    console.log(`Returning already existing instance`);
+                    return this._value;
+                }
+                return this._value;
+            case Query_1.returnAs.AS_OBJECTURIS:
+            default:
+                return this._value;
+        }
     }
     set(value) {
         if (value instanceof ObjectUri_1.ObjectUri &&
@@ -23,8 +76,8 @@ class ObjectProperty extends BaseProperty_1.BaseProperty {
             return this._value.toJSON();
         }
         return this._value &&
-            (this._value.core.dataObject || this._value instanceof DataObject_1.DataObject)
-            ? this._value.core.dataObject.toReference()
+            (this._value.dataObject || this._value instanceof DataObject_1.DataObject)
+            ? this._value.dataObject.toReference()
             : null;
     }
 }

package/lib/properties/Property.d.ts

@@ -1,5 +1,12 @@
 import { DataObjectClass } from '../components/types/DataObjectClass';
-import { BaseProperty, BasePropertyType } from './BaseProperty';
+import { BaseProperty } from './BaseProperty';
+import { BooleanPropertyType } from './BooleanProperty';
+import { DateTimePropertyType } from './DateTimeProperty';
+import { EnumPropertyType } from './EnumProperty';
+import { HashPropertyType } from './HashProperty';
+import { StringPropertyType } from './StringProperty';
+import { NumberPropertyType } from './NumberProperty';
+import { ObjectPropertyType } from './ObjectProperty';
 export declare class Property {
     static TYPE_ANY: string;
     static TYPE_NUMBER: string;
@@ -11,5 +18,5 @@ export declare class Property {
     static TYPE_DATETIME: string;
     static TYPE_ARRAY: string;
     static TYPE_MAP: string;
-    static factory<P extends BasePropertyType>(params: P, parent: DataObjectClass<any>): BaseProperty;
+    static factory(params: ObjectPropertyType & StringPropertyType & NumberPropertyType & EnumPropertyType & BooleanPropertyType & HashPropertyType & DateTimePropertyType, parent: DataObjectClass<any>): BaseProperty;
 }

package/lib/properties/StringProperty.d.ts

@@ -1,6 +1,6 @@
 import { BaseProperty, BasePropertyType } from './BaseProperty';
 export interface StringPropertyType extends BasePropertyType {
-    minLength?: number;
+    minLength: number;
     maxLength?: number;
     allowSpaces?: boolean;
     allowDigits?: boolean;

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": "0.5.6",
+   "version": "1.0.0-beta2",
    "description": "Core objects for business apps",
    "main": "lib/index.js",
    "types": "lib/index.d.ts",
@@ -26,7 +26,8 @@
    "scripts": {
       "test": "tsc && jest --verbose",
       "build": "tsc --watch",
-      "push": "yarn version --patch --no-git-tag-version ; yarn publish --access public",
+      "patch": "yarn version --patch --no-git-tag-version",
+      "push": "yarn publish --access public",
       "prepublish": "tsc"
    }
-}
+}