@quatrain/core 0.1.6

package/lib/components/User.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = exports.UserProperties = void 0;
+const Property_1 = require("../properties/Property");
+const HashProperty_1 = require("../properties/HashProperty");
+const BaseObject_1 = require("./BaseObject");
+/**
+ * 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: Property_1.Property.TYPE_STRING,
+        minLength: 0,
+    },
+    {
+        name: 'firstname',
+        mandatory: true,
+        type: Property_1.Property.TYPE_STRING,
+        minLength: 1,
+        maxLength: 100,
+        onChange,
+    },
+    {
+        name: 'lastname',
+        mandatory: true,
+        type: Property_1.Property.TYPE_STRING,
+        minLength: 1,
+        maxLength: 100,
+        onChange,
+    },
+    {
+        name: 'email',
+        mandatory: true,
+        type: Property_1.Property.TYPE_STRING,
+        minLength: 1,
+        maxLength: 100,
+    },
+    {
+        name: 'password',
+        mandatory: true,
+        type: Property_1.Property.TYPE_HASH,
+        algorithm: HashProperty_1.HashProperty.ALGORITHM_SHA256,
+        salt: '',
+        minLength: 5,
+        maxLength: 20, // this is for the clear password
+    },
+];
+class User extends BaseObject_1.BaseObject {
+}
+exports.User = User;
+User.PROPS_DEFINITION = exports.UserProperties;

package/lib/components/index.d.ts

@@ -0,0 +1,7 @@
+import { DataObject } from './DataObject';
+import { ObjectUri } from './ObjectUri';
+import { AbstractObject } from './AbstractObject';
+import { BaseObject } from './BaseObject';
+import { BaseObjectProperties } from './BaseObjectProperties';
+import { User, UserProperties } from './User';
+export { DataObject, ObjectUri, AbstractObject, BaseObject, User, BaseObjectProperties, UserProperties, };

package/lib/components/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserProperties = exports.BaseObjectProperties = exports.User = exports.BaseObject = 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");
+Object.defineProperty(exports, "ObjectUri", { enumerable: true, get: function () { return ObjectUri_1.ObjectUri; } });
+const AbstractObject_1 = require("./AbstractObject");
+Object.defineProperty(exports, "AbstractObject", { enumerable: true, get: function () { return AbstractObject_1.AbstractObject; } });
+const BaseObject_1 = require("./BaseObject");
+Object.defineProperty(exports, "BaseObject", { enumerable: true, get: function () { return BaseObject_1.BaseObject; } });
+const BaseObjectProperties_1 = require("./BaseObjectProperties");
+Object.defineProperty(exports, "BaseObjectProperties", { enumerable: true, get: function () { return BaseObjectProperties_1.BaseObjectProperties; } });
+const User_1 = require("./User");
+Object.defineProperty(exports, "User", { enumerable: true, get: function () { return User_1.User; } });
+Object.defineProperty(exports, "UserProperties", { enumerable: true, get: function () { return User_1.UserProperties; } });

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+import { Core } from './Core';
+import * as statuses from './common/statuses';
+import { Property } from './properties/Property';
+import { BaseProperty, BasePropertyType } from './properties/BaseProperty';
+import { StringProperty, StringPropertyType } from './properties/StringProperty';
+import { EnumProperty, EnumPropertyType } from './properties/EnumProperty';
+import { BooleanProperty, BooleanPropertyType } from './properties/BooleanProperty';
+import { ObjectProperty, ObjectPropertyType } from './properties/ObjectProperty';
+import { DateTimeProperty, DateTimePropertyType } from './properties/DateTimeProperty';
+import { HashProperty, HashPropertyType } from './properties/HashProperty';
+import { AbstractObject } from './components/AbstractObject';
+import { ObjectUri } from './components/ObjectUri';
+import { DataObject } from './components/DataObject';
+import { BaseObject } from './components/BaseObject';
+import { BaseObjectProperties } from './components/BaseObjectProperties';
+import { AbstractAdapter, MockAdapter, BackendError, BackendParameters, Query, Filter, Filters, Limits, Sorting, SortAndLimit } from './backends';
+export { statuses, Core, Property, BaseProperty, BasePropertyType, BooleanProperty, BooleanPropertyType, DateTimeProperty, DateTimePropertyType, EnumProperty, EnumPropertyType, HashProperty, HashPropertyType, ObjectProperty, ObjectPropertyType, StringProperty, StringPropertyType, AbstractAdapter, MockAdapter, ObjectUri, DataObject, AbstractObject, BaseObject, BaseObjectProperties, BackendParameters, BackendError, Query, Filter, Filters, Limits, Sorting, SortAndLimit, };

package/lib/index.js

@@ -0,0 +1,66 @@
+"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.Sorting = exports.Limits = exports.Filters = exports.Filter = exports.Query = exports.BackendError = exports.BaseObjectProperties = exports.BaseObject = 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.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"));
+exports.statuses = statuses;
+const Property_1 = require("./properties/Property");
+Object.defineProperty(exports, "Property", { enumerable: true, get: function () { return Property_1.Property; } });
+const BaseProperty_1 = require("./properties/BaseProperty");
+Object.defineProperty(exports, "BaseProperty", { enumerable: true, get: function () { return BaseProperty_1.BaseProperty; } });
+const StringProperty_1 = require("./properties/StringProperty");
+Object.defineProperty(exports, "StringProperty", { enumerable: true, get: function () { return StringProperty_1.StringProperty; } });
+const EnumProperty_1 = require("./properties/EnumProperty");
+Object.defineProperty(exports, "EnumProperty", { enumerable: true, get: function () { return EnumProperty_1.EnumProperty; } });
+const BooleanProperty_1 = require("./properties/BooleanProperty");
+Object.defineProperty(exports, "BooleanProperty", { enumerable: true, get: function () { return BooleanProperty_1.BooleanProperty; } });
+const ObjectProperty_1 = require("./properties/ObjectProperty");
+Object.defineProperty(exports, "ObjectProperty", { enumerable: true, get: function () { return ObjectProperty_1.ObjectProperty; } });
+const DateTimeProperty_1 = require("./properties/DateTimeProperty");
+Object.defineProperty(exports, "DateTimeProperty", { enumerable: true, get: function () { return DateTimeProperty_1.DateTimeProperty; } });
+const HashProperty_1 = require("./properties/HashProperty");
+Object.defineProperty(exports, "HashProperty", { enumerable: true, get: function () { return HashProperty_1.HashProperty; } });
+const AbstractObject_1 = require("./components/AbstractObject");
+Object.defineProperty(exports, "AbstractObject", { enumerable: true, get: function () { return AbstractObject_1.AbstractObject; } });
+const ObjectUri_1 = require("./components/ObjectUri");
+Object.defineProperty(exports, "ObjectUri", { enumerable: true, get: function () { return ObjectUri_1.ObjectUri; } });
+const DataObject_1 = require("./components/DataObject");
+Object.defineProperty(exports, "DataObject", { enumerable: true, get: function () { return DataObject_1.DataObject; } });
+const BaseObject_1 = require("./components/BaseObject");
+Object.defineProperty(exports, "BaseObject", { enumerable: true, get: function () { return BaseObject_1.BaseObject; } });
+const BaseObjectProperties_1 = require("./components/BaseObjectProperties");
+Object.defineProperty(exports, "BaseObjectProperties", { enumerable: true, get: function () { return BaseObjectProperties_1.BaseObjectProperties; } });
+const backends_1 = require("./backends");
+Object.defineProperty(exports, "AbstractAdapter", { enumerable: true, get: function () { return backends_1.AbstractAdapter; } });
+Object.defineProperty(exports, "MockAdapter", { enumerable: true, get: function () { return backends_1.MockAdapter; } });
+Object.defineProperty(exports, "BackendError", { enumerable: true, get: function () { return backends_1.BackendError; } });
+Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return backends_1.Query; } });
+Object.defineProperty(exports, "Filter", { enumerable: true, get: function () { return backends_1.Filter; } });
+Object.defineProperty(exports, "Filters", { enumerable: true, get: function () { return backends_1.Filters; } });
+Object.defineProperty(exports, "Limits", { enumerable: true, get: function () { return backends_1.Limits; } });
+Object.defineProperty(exports, "Sorting", { enumerable: true, get: function () { return backends_1.Sorting; } });
+Object.defineProperty(exports, "SortAndLimit", { enumerable: true, get: function () { return backends_1.SortAndLimit; } });

package/lib/properties/BaseProperty.d.ts

@@ -0,0 +1,34 @@
+import { DataObject } from '../components/DataObject';
+import { AbstractPropertyType } from './types/AbstractPropertyType';
+import { PropertyClassType } from './types/PropertyClassType';
+export declare type EventTypes = typeof BaseProperty.EVENT_ONCHANGE | typeof BaseProperty.EVENT_ONDELETE;
+export interface BasePropertyType extends AbstractPropertyType {
+    parent?: DataObject;
+    protected?: boolean;
+    mandatory?: boolean;
+    defaultValue?: any;
+    onChange?: (dao: DataObject) => DataObject;
+}
+export declare class BaseProperty implements PropertyClassType {
+    static EVENT_ONCHANGE: string;
+    static EVENT_ONDELETE: string;
+    protected _parent: DataObject | undefined;
+    protected _name: string;
+    protected _value: any;
+    protected _mandatory: boolean;
+    protected _protected: boolean;
+    protected _allows: String[];
+    protected _defaultValue: any;
+    protected _events: {
+        [key: EventTypes]: Function;
+    };
+    constructor(config: BasePropertyType);
+    get name(): string;
+    get mandatory(): boolean;
+    get protected(): boolean;
+    get allows(): String[];
+    set(value: any): this;
+    val(transform?: any): any;
+    protected _enable(value: boolean | undefined): boolean;
+    toJSON(): any;
+}

package/lib/properties/BaseProperty.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProperty = void 0;
+class BaseProperty {
+    constructor(config) {
+        this._value = undefined;
+        this._mandatory = false;
+        this._protected = false;
+        this._allows = [];
+        this._events = {};
+        this._parent = config.parent;
+        this._name = config.name;
+        this._protected = config.protected || false;
+        this._mandatory = config.mandatory || false;
+        this._defaultValue = config.defaultValue;
+        this._value = config.defaultValue;
+        if (typeof config.onChange === 'function') {
+            this._events.onChange = config.onChange;
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    get mandatory() {
+        return this._mandatory;
+    }
+    get protected() {
+        return this._protected;
+    }
+    get allows() {
+        return this._allows;
+    }
+    set(value) {
+        if (this._value !== undefined &&
+            this._value !== this._defaultValue &&
+            this._protected === true) {
+            throw new Error(`Value already defined as '${this._value}' and protected from change`);
+        }
+        this._value = value;
+        if (this._events[BaseProperty.EVENT_ONCHANGE]) {
+            this._events[BaseProperty.EVENT_ONCHANGE](this._parent);
+        }
+        return this;
+    }
+    val(transform = undefined) {
+        return this._value;
+    }
+    _enable(value) {
+        return value === undefined || value === true;
+    }
+    toJSON() {
+        return this._value;
+    }
+}
+exports.BaseProperty = BaseProperty;
+BaseProperty.EVENT_ONCHANGE = 'onChange';
+BaseProperty.EVENT_ONDELETE = 'onDelete';

package/lib/properties/BooleanProperty.d.ts

@@ -0,0 +1,6 @@
+import { BaseProperty, BasePropertyType } from './';
+export interface BooleanPropertyType extends BasePropertyType {
+}
+export declare class BooleanProperty extends BaseProperty {
+    set(value: boolean): this;
+}

package/lib/properties/BooleanProperty.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanProperty = void 0;
+const _1 = require("./");
+class BooleanProperty extends _1.BaseProperty {
+    set(value) {
+        return super.set(value);
+    }
+}
+exports.BooleanProperty = BooleanProperty;

package/lib/properties/DateTimeProperty.d.ts

@@ -0,0 +1,10 @@
+import { BaseProperty, BasePropertyType } from './BaseProperty';
+export interface DateTimePropertyType extends BasePropertyType {
+    timezone?: string;
+}
+export declare class DateTimeProperty extends BaseProperty {
+    protected _timezone: string;
+    constructor(config: DateTimePropertyType);
+    set(value: string | Date): this;
+    get timezone(): string;
+}

package/lib/properties/DateTimeProperty.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTimeProperty = void 0;
+const BaseProperty_1 = require("./BaseProperty");
+class DateTimeProperty extends BaseProperty_1.BaseProperty {
+    constructor(config) {
+        super(config);
+        this._timezone = config.timezone || 'Z';
+    }
+    set(value) {
+        return super.set(value);
+    }
+    get timezone() {
+        return this._timezone;
+    }
+}
+exports.DateTimeProperty = DateTimeProperty;

package/lib/properties/EnumProperty.d.ts

@@ -0,0 +1,9 @@
+import { BaseProperty, BasePropertyType } from './BaseProperty';
+export interface EnumPropertyType extends BasePropertyType {
+    values?: string[];
+}
+export declare class EnumProperty extends BaseProperty {
+    protected _values: string[];
+    constructor(config: EnumPropertyType);
+    set(value: string): this;
+}

package/lib/properties/EnumProperty.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumProperty = void 0;
+const BaseProperty_1 = require("./BaseProperty");
+class EnumProperty extends BaseProperty_1.BaseProperty {
+    constructor(config) {
+        super(config);
+        this._values = [];
+        this._values = config.values || [];
+    }
+    set(value) {
+        if (!this._values.includes(value)) {
+            throw new Error(`Value '${value}' is not acceptable`);
+        }
+        return super.set(value);
+    }
+}
+exports.EnumProperty = EnumProperty;

package/lib/properties/HashProperty.d.ts

@@ -0,0 +1,20 @@
+import { StringProperty, StringPropertyType } from './StringProperty';
+export declare type HashPropertyAlgos = typeof HashProperty.ALGORITHM_MD5 | typeof HashProperty.ALGORITHM_SHA1 | typeof HashProperty.ALGORITHM_SHA256;
+export interface HashPropertyType extends StringPropertyType {
+    algorithm?: HashPropertyAlgos;
+    salt?: string;
+    prefixed?: boolean;
+}
+export declare class HashProperty extends StringProperty {
+    static ALGORITHM_MD5: string;
+    static ALGORITHM_SHA1: string;
+    static ALGORITHM_SHA256: string;
+    static ALGORITHM_BCRYPT: string;
+    protected _algorithm: HashPropertyAlgos;
+    protected _salt: string;
+    protected _prefixed: boolean;
+    constructor(config: HashPropertyType);
+    _hash(value: string): string;
+    set(value: string): this;
+    compare(value: string): boolean;
+}

package/lib/properties/HashProperty.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashProperty = void 0;
+const StringProperty_1 = require("./StringProperty");
+class HashProperty extends StringProperty_1.StringProperty {
+    constructor(config) {
+        super(config);
+        this._salt = '';
+        this._prefixed = false;
+        this._algorithm = config.algorithm || HashProperty.ALGORITHM_MD5;
+        this._salt = config.salt || '';
+        this._prefixed = config.prefixed || false;
+    }
+    _hash(value) {
+        const crypto = require('crypto');
+        let algo;
+        switch (this._algorithm) {
+            case HashProperty.ALGORITHM_MD5:
+                algo = crypto.createHash('md5');
+                break;
+            case HashProperty.ALGORITHM_SHA1:
+                algo = crypto.createHash('sha1');
+                break;
+            case HashProperty.ALGORITHM_SHA256:
+                algo = crypto.createHash('sha256');
+                break;
+            case HashProperty.ALGORITHM_BCRYPT:
+                break;
+            default:
+                throw new Error(`Insupported or missing hash algorithm`);
+        }
+        let hash = this._prefixed ? `${this._algorithm}-` : '';
+        hash += algo.update(`${this._salt}${value}`).digest('hex');
+        this._rawValue = false; // don't test some constraints after hashing
+        return hash;
+    }
+    set(value) {
+        return super.set(this._hash(value));
+    }
+    compare(value) {
+        return this._hash(value) === this._value;
+    }
+}
+exports.HashProperty = HashProperty;
+HashProperty.ALGORITHM_MD5 = 'md5';
+HashProperty.ALGORITHM_SHA1 = 'sha1';
+HashProperty.ALGORITHM_SHA256 = 'sha256';
+HashProperty.ALGORITHM_BCRYPT = 'bcrypt';

package/lib/properties/NumberProperty.d.ts

@@ -0,0 +1,36 @@
+import { BaseProperty, BasePropertyType } from './BaseProperty';
+export declare type NumberSign = typeof NumberProperty.TYPE_SIGNED | typeof NumberProperty.TYPE_UNSIGNED;
+export declare type NumberType = typeof NumberProperty.TYPE_INTEGER | typeof NumberProperty.TYPE_FLOAT;
+export interface NumberPropertyType extends BasePropertyType {
+    minVal?: number;
+    maxVal?: number;
+    sign?: NumberSign;
+    type?: NumberType;
+    prefix?: string;
+    suffix?: string;
+    precision?: number;
+}
+export declare class NumberProperty extends BaseProperty {
+    static TYPE_SIGNED: string;
+    static TYPE_UNSIGNED: string;
+    static TYPE_INTEGER: string;
+    static TYPE_FLOAT: string;
+    static SEPARATOR: string;
+    static TRANSFORM_FORMATTED: string;
+    protected _minVal: number | undefined;
+    protected _maxVal: number | undefined;
+    protected _type: NumberType;
+    protected _sign: NumberSign;
+    protected _prefix: string;
+    protected _suffix: string;
+    protected _precision: number;
+    protected _value: number | undefined;
+    constructor(config: NumberPropertyType);
+    set(value: number): this;
+    val(transform?: string | undefined): string | number | undefined;
+    set minVal(min: number | undefined);
+    get minVal(): number | undefined;
+    set maxVal(max: number | undefined);
+    get maxVal(): number | undefined;
+    get type(): string;
+}

package/lib/properties/NumberProperty.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberProperty = void 0;
+const BaseProperty_1 = require("./BaseProperty");
+class NumberProperty extends BaseProperty_1.BaseProperty {
+    constructor(config) {
+        super(config);
+        this._minVal = undefined;
+        this._maxVal = undefined;
+        this._type = NumberProperty.TYPE_INTEGER;
+        this._sign = NumberProperty.TYPE_SIGNED;
+        this._prefix = '';
+        this._suffix = '';
+        this._precision = 0;
+        this.minVal = config.minVal || undefined;
+        this.maxVal = config.maxVal || undefined;
+        this._prefix = config.prefix
+            ? `${config.prefix}${NumberProperty.SEPARATOR}`
+            : '';
+        this._suffix = config.suffix
+            ? `${NumberProperty.SEPARATOR}${config.suffix}`
+            : '';
+        if (config.type) {
+            this._type = config.type;
+        }
+        if (config.sign) {
+            this._sign = config.sign;
+        }
+    }
+    set(value) {
+        if (this._sign === NumberProperty.TYPE_UNSIGNED && value < 0) {
+            throw new Error(`Value must be unsigned`);
+        }
+        if (this._minVal && value < this._minVal) {
+            throw new Error(`Value is below ${this._minVal}`);
+        }
+        if (this._maxVal && value > this._maxVal) {
+            throw new Error(`Value is above ${this._maxVal}`);
+        }
+        if (this._type === NumberProperty.TYPE_INTEGER) {
+            value = Math.floor(value);
+        }
+        return super.set(value);
+    }
+    val(transform = undefined) {
+        switch (transform) {
+            case NumberProperty.TRANSFORM_FORMATTED:
+                return `${this._prefix}${this._value}${this._suffix}`;
+            default:
+                return this._value;
+        }
+    }
+    set minVal(min) {
+        this._minVal = min;
+    }
+    get minVal() {
+        return this._minVal;
+    }
+    set maxVal(max) {
+        this._maxVal = max;
+    }
+    get maxVal() {
+        return this._maxVal;
+    }
+    get type() {
+        return this._type;
+    }
+}
+exports.NumberProperty = NumberProperty;
+NumberProperty.TYPE_SIGNED = 'signed';
+NumberProperty.TYPE_UNSIGNED = 'unsigned';
+NumberProperty.TYPE_INTEGER = 'integer';
+NumberProperty.TYPE_FLOAT = 'float';
+NumberProperty.SEPARATOR = ' ';
+NumberProperty.TRANSFORM_FORMATTED = 'formatted';

package/lib/properties/ObjectProperty.d.ts

@@ -0,0 +1,16 @@
+import { BaseObject } from '../components';
+import { BaseProperty, BasePropertyType } from './BaseProperty';
+export interface ObjectPropertyType extends BasePropertyType {
+    instanceOf?: Function | string | Object;
+}
+export declare class ObjectProperty extends BaseProperty {
+    _value: BaseObject | undefined;
+    _instanceOf: Function | string | Object;
+    constructor(config: ObjectPropertyType);
+    set(value: any): this;
+    toJSON(): {
+        label: any;
+        ref: string;
+        uri: string;
+    } | undefined;
+}

package/lib/properties/ObjectProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectProperty = void 0;
+const DataObject_1 = require("../components/DataObject");
+const ObjectUri_1 = require("../components/ObjectUri");
+const BaseProperty_1 = require("./BaseProperty");
+class ObjectProperty extends BaseProperty_1.BaseProperty {
+    constructor(config) {
+        super(config);
+        this._value = undefined;
+        this._instanceOf = config.instanceOf || Object;
+    }
+    set(value) {
+        if (value instanceof ObjectUri_1.ObjectUri &&
+            value instanceof DataObject_1.DataObject &&
+            value.constructor.name !== this._instanceOf.constructor.name) {
+            throw new Error(`value ${JSON.stringify(value)} is not an instance of ${this._instanceOf.constructor.name}`);
+        }
+        return super.set(value);
+    }
+    toJSON() {
+        return this._value && this._value.dataObject ? this._value.dataObject.toReference() : undefined;
+    }
+}
+exports.ObjectProperty = ObjectProperty;

package/lib/properties/Property.d.ts

@@ -0,0 +1,16 @@
+import { DataObject } from '../components/DataObject';
+import { BaseProperty, BasePropertyType } from './BaseProperty';
+export declare class Property {
+    static TYPE_ANY: string;
+    static TYPE_NUMBER: string;
+    static TYPE_STRING: string;
+    static TYPE_OBJECT: string;
+    static TYPE_ENUM: string;
+    static TYPE_BOOLEAN: string;
+    static TYPE_HASH: string;
+    static TYPE_DATETIME: string;
+    static ALLOW_SPACES: string;
+    static ALLOW_LETTERS: string;
+    static ALLOW_DIGITS: string;
+    static factory<P extends BasePropertyType>(params: P, parent: DataObject): BaseProperty;
+}

package/lib/properties/Property.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Property = void 0;
+const BaseProperty_1 = require("./BaseProperty");
+const BooleanProperty_1 = require("./BooleanProperty");
+const DateTimeProperty_1 = require("./DateTimeProperty");
+const EnumProperty_1 = require("./EnumProperty");
+const HashProperty_1 = require("./HashProperty");
+const ObjectProperty_1 = require("./ObjectProperty");
+const StringProperty_1 = require("./StringProperty");
+const NumberProperty_1 = require("./NumberProperty");
+class Property {
+    static factory(params, parent) {
+        params.parent = parent;
+        //   console.log(`Creating ${params.type} property named ${params.name}`)
+        switch (params.type) {
+            case Property.TYPE_ANY:
+                return new BaseProperty_1.BaseProperty(params);
+            case Property.TYPE_STRING:
+                return new StringProperty_1.StringProperty(params);
+            case Property.TYPE_NUMBER:
+                return new NumberProperty_1.NumberProperty(params);
+            case Property.TYPE_OBJECT:
+                return new ObjectProperty_1.ObjectProperty(params);
+            case Property.TYPE_ENUM:
+                return new EnumProperty_1.EnumProperty(params);
+            case Property.TYPE_BOOLEAN:
+                return new BooleanProperty_1.BooleanProperty(params);
+            case Property.TYPE_HASH:
+                return new HashProperty_1.HashProperty(params);
+            case Property.TYPE_DATETIME:
+                return new DateTimeProperty_1.DateTimeProperty(params);
+            default:
+                throw new Error(`Unknown property type ${params.type}`);
+        }
+    }
+}
+exports.Property = Property;
+Property.TYPE_ANY = 'any';
+Property.TYPE_NUMBER = 'number';
+Property.TYPE_STRING = 'string';
+Property.TYPE_OBJECT = 'object';
+Property.TYPE_ENUM = 'enum';
+Property.TYPE_BOOLEAN = 'boolean';
+Property.TYPE_HASH = 'hash';
+Property.TYPE_DATETIME = 'datetime';
+Property.ALLOW_SPACES = 'spaces';
+Property.ALLOW_LETTERS = 'letters';
+Property.ALLOW_DIGITS = 'digits';

package/lib/properties/StringProperty.d.ts

@@ -0,0 +1,27 @@
+import { BaseProperty, BasePropertyType } from './BaseProperty';
+export interface StringPropertyType extends BasePropertyType {
+    minLength?: number;
+    maxLength?: number;
+    allowSpaces?: boolean;
+    allowDigits?: boolean;
+    allowLetters?: boolean;
+    allowPattern?: String;
+}
+export declare class StringProperty extends BaseProperty {
+    static TRANSFORM_UCASE: string;
+    static TRANSFORM_LCASE: string;
+    protected _minLength: number;
+    protected _maxLength: number;
+    protected _value: string | undefined;
+    /**
+     * Set to false to bypass some rules
+     */
+    protected _rawValue: boolean;
+    constructor(config: StringPropertyType);
+    set(value: any): this;
+    get(transform?: string | undefined): string | undefined;
+    set minLength(min: number);
+    get minLength(): number;
+    set maxLength(max: number);
+    get maxLength(): number;
+}