functional-models 1.1.0 → 1.1.4

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "functional-models",
-  "version": "1.1.0",
+  "version": "1.1.4",
   "description": "A library for creating JavaScript function based models.",
-  "main": "src/index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "test": "mocha -r ts-node/register test/**/*.test.ts",
     "test:coverage": "nyc npm run test",
     "feature-tests": "./node_modules/.bin/cucumber-js -p default",
-    "coverage": "nyc --all --reporter=lcov npm test"
+    "coverage": "nyc --all --reporter=lcov npm test",
+    "dist": "tsc && cp package.json ./dist && cp README.md ./dist && cd dist && npm publish"
   },
   "repository": {
     "type": "git",

package/src/constants.d.ts

@@ -0,0 +1,14 @@
+declare enum PROPERTY_TYPES {
+    UniqueId = "UniqueId",
+    DateProperty = "DateProperty",
+    ArrayProperty = "ArrayProperty",
+    ReferenceProperty = "ReferenceProperty",
+    IntegerProperty = "IntegerProperty",
+    TextProperty = "TextProperty",
+    ConstantValueProperty = "ConstantValueProperty",
+    NumberProperty = "NumberProperty",
+    ObjectProperty = "ObjectProperty",
+    EmailProperty = "EmailProperty",
+    BooleanProperty = "BooleanProperty"
+}
+export { PROPERTY_TYPES };

package/src/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROPERTY_TYPES = void 0;
+var PROPERTY_TYPES;
+(function (PROPERTY_TYPES) {
+    PROPERTY_TYPES["UniqueId"] = "UniqueId";
+    PROPERTY_TYPES["DateProperty"] = "DateProperty";
+    PROPERTY_TYPES["ArrayProperty"] = "ArrayProperty";
+    PROPERTY_TYPES["ReferenceProperty"] = "ReferenceProperty";
+    PROPERTY_TYPES["IntegerProperty"] = "IntegerProperty";
+    PROPERTY_TYPES["TextProperty"] = "TextProperty";
+    PROPERTY_TYPES["ConstantValueProperty"] = "ConstantValueProperty";
+    PROPERTY_TYPES["NumberProperty"] = "NumberProperty";
+    PROPERTY_TYPES["ObjectProperty"] = "ObjectProperty";
+    PROPERTY_TYPES["EmailProperty"] = "EmailProperty";
+    PROPERTY_TYPES["BooleanProperty"] = "BooleanProperty";
+})(PROPERTY_TYPES || (PROPERTY_TYPES = {}));
+exports.PROPERTY_TYPES = PROPERTY_TYPES;
+//# sourceMappingURL=constants.js.map

package/src/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":";;;AAAA,IAAK,cAYJ;AAZD,WAAK,cAAc;IACjB,uCAAqB,CAAA;IACrB,+CAA6B,CAAA;IAC7B,iDAA+B,CAAA;IAC/B,yDAAuC,CAAA;IACvC,qDAAmC,CAAA;IACnC,+CAA6B,CAAA;IAC7B,iEAA+C,CAAA;IAC/C,mDAAiC,CAAA;IACjC,mDAAiC,CAAA;IACjC,iDAA+B,CAAA;IAC/B,qDAAmC,CAAA;AACrC,CAAC,EAZI,cAAc,KAAd,cAAc,QAYlB;AAEQ,wCAAc"}

package/src/errors.d.ts

@@ -0,0 +1,9 @@
+declare type KeysToErrors = {
+    [s: string]: string[];
+};
+declare class ValidationError extends Error {
+    modelName: String;
+    keysToErrors: KeysToErrors;
+    constructor(modelName: String, keysToErrors: KeysToErrors);
+}
+export { ValidationError };

package/src/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = void 0;
+/* eslint-disable functional/no-this-expression */
+/* eslint-disable functional/no-class */
+class ValidationError extends Error {
+    constructor(modelName, keysToErrors) {
+        super(`${modelName} did not pass validation`);
+        this.name = 'ValidationError';
+        this.modelName = modelName;
+        this.keysToErrors = keysToErrors;
+    }
+}
+exports.ValidationError = ValidationError;
+//# sourceMappingURL=errors.js.map

package/src/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":";;;AAEA,kDAAkD;AAClD,wCAAwC;AACxC,MAAM,eAAgB,SAAQ,KAAK;IAGjC,YAAY,SAAiB,EAAE,YAA0B;QACvD,KAAK,CAAC,GAAG,SAAS,0BAA0B,CAAC,CAAA;QAC7C,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAA;QAC7B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;IAClC,CAAC;CACF;AAIQ,0CAAe"}

package/src/index.d.ts

@@ -0,0 +1,10 @@
+import * as constants from './constants';
+import * as errors from './errors';
+import * as validation from './validation';
+import * as serialization from './serialization';
+import * as utils from './utils';
+import * as interfaces from './interfaces';
+export * from './models';
+export * from './properties';
+export * from './methods';
+export { constants, errors, validation, serialization, utils, interfaces };

package/src/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interfaces = exports.utils = exports.serialization = exports.validation = exports.errors = exports.constants = void 0;
+const constants = __importStar(require("./constants"));
+exports.constants = constants;
+const errors = __importStar(require("./errors"));
+exports.errors = errors;
+const validation = __importStar(require("./validation"));
+exports.validation = validation;
+const serialization = __importStar(require("./serialization"));
+exports.serialization = serialization;
+const utils = __importStar(require("./utils"));
+exports.utils = utils;
+const interfaces = __importStar(require("./interfaces"));
+exports.interfaces = interfaces;
+__exportStar(require("./models"), exports);
+__exportStar(require("./properties"), exports);
+__exportStar(require("./methods"), exports);
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uDAAwC;AAW/B,8BAAS;AAVlB,iDAAkC;AAUd,wBAAM;AAT1B,yDAA0C;AASd,gCAAU;AARtC,+DAAgD;AAQR,sCAAa;AAPrD,+CAAgC;AAOuB,sBAAK;AAN5D,yDAA0C;AAMoB,gCAAU;AAJxE,2CAAwB;AACxB,+CAA4B;AAC5B,4CAAyB"}

package/src/interfaces.d.ts

@@ -0,0 +1,145 @@
+declare type MaybeFunction<T> = T | (() => T);
+declare type MaybePromise<T> = T | Promise<T>;
+declare type Nullable<T> = T | null;
+declare type Maybe<T> = T | undefined | null;
+declare type Arrayable<T> = T | readonly T[];
+declare type MaybeLazy<T> = Maybe<Promise<T>>;
+declare type MaybeEmpty<T> = T | null | undefined;
+declare type JsonAble = number | string | boolean | null | Arrayable<{
+    readonly [s: string]: JsonAble;
+}>;
+declare type VeryPrimitivesTypes = null | string | number | boolean;
+declare type toObj = () => Promise<JsonAble>;
+declare type ValueIsOfType<T, V> = {
+    readonly [P in keyof T as T[P] extends V ? P : never]: T[P];
+};
+declare type ValueIsNotOfType<T, V> = {
+    readonly [P in keyof T as T[P] extends V ? never : P]: T[P];
+};
+declare type InstanceMethodGetters<T> = {
+    readonly [P in keyof T as T[P] extends ModelInstanceMethod ? P : never]: ModelInstanceMethodClient;
+};
+declare type ModelMethodGetters<T> = {
+    readonly [P in keyof T as T[P] extends ModelMethod ? P : never]: ModelMethodClient;
+};
+declare type ModelMethodTypes<T extends FunctionalModel> = ModelMethod | ModelInstanceMethod | ModelMethodTyped<T> | ModelInstanceMethodTyped<T>;
+declare type PropertyGetters<T extends FunctionalModel> = {
+    readonly [Property in keyof T as T[Property] extends ModelMethodTypes<T> ? never : Property]: () => T[Property] | Promise<T[Property]>;
+};
+declare type FunctionalModel = {
+    readonly [s: string]: Arrayable<number> | Arrayable<string> | Arrayable<boolean> | Arrayable<null> | Arrayable<FunctionalModel> | Arrayable<Date> | Arrayable<undefined> | ReferenceValueType<any> | ModelInstanceMethod | ModelMethod;
+} | JsonAble;
+declare type FunctionalType = JsonAble | (() => FunctionalType) | Arrayable<undefined> | Arrayable<Date> | Arrayable<FunctionalModel> | Arrayable<{
+    readonly [s: string]: JsonAble;
+}>;
+declare type ModelInstanceInputData<T extends FunctionalModel> = ValueIsNotOfType<T, ModelMethodTypes<T>>;
+declare type PropertyValidatorComponentTypeAdvanced<TValue, TModel extends FunctionalModel> = (value: TValue, instance: ModelInstance<TModel>, instanceData: FunctionalModel) => string | undefined;
+declare type PropertyValidatorComponentType<TValue> = (value: TValue, instance: ModelInstance<any>, instanceData: FunctionalModel) => string | undefined;
+declare type PropertyValidatorComponentSync = PropertyValidatorComponentType<any>;
+declare type PropertyValidatorComponentAsync = (value: Arrayable<FunctionalModel>, instance: ModelInstance<any>, instanceData: FunctionalModel) => Promise<string | undefined>;
+declare type PropertyValidatorComponent = PropertyValidatorComponentSync | PropertyValidatorComponentAsync;
+declare type PropertyValidator = (instance: ModelInstance<any>, instanceData: FunctionalModel) => Promise<ValidationErrors>;
+declare type ValidationError = string | undefined;
+declare type ValidationErrors = readonly ValidationError[];
+declare type ModelError = string;
+declare type ModelErrors = {
+    readonly [s: string]: readonly ModelError[];
+};
+declare type ModelComponentValidator = (instance: ModelInstance<any>, instanceData: FunctionalModel, options?: object) => Promise<ValidationErrors>;
+declare type ValueGetter = () => MaybePromise<Arrayable<FunctionalType>> | MaybePromise<ModelInstance<any>>;
+declare type PropertyInstance<T extends Arrayable<FunctionalType>> = {
+    readonly getConfig: () => object;
+    readonly getChoices: () => readonly VeryPrimitivesTypes[];
+    readonly getDefaultValue: () => T;
+    readonly getConstantValue: () => T;
+    readonly getPropertyType: () => string;
+    readonly createGetter: (value: T) => ValueGetter;
+    readonly getValidator: (valueGetter: ValueGetter) => PropertyValidator;
+};
+declare type PropertiesList<T> = {
+    readonly [P in keyof T as T[P] extends Arrayable<FunctionalType> ? P : never]: PropertyInstance<any>;
+};
+interface ReferencePropertyInstance<T extends FunctionalModel> extends PropertyInstance<ModelInstance<T> | T | MaybeEmpty<PrimaryKeyType>> {
+    readonly getReferencedId: (instanceValues: ReferenceValueType<T>) => MaybeEmpty<PrimaryKeyType>;
+    readonly getReferencedModel: () => Model<T>;
+}
+declare type ReferenceValueType<T extends FunctionalModel> = ModelInstance<T> | ModelInstanceInputData<T> | string | number | null | undefined;
+declare type DefaultPropertyValidators = {
+    readonly required?: boolean;
+    readonly isInteger?: boolean;
+    readonly isNumber?: boolean;
+    readonly isString?: boolean;
+    readonly isArray?: boolean;
+    readonly isBoolean?: boolean;
+};
+declare type PropertyConfigContents = {
+    readonly type?: string;
+    readonly defaultValue?: Arrayable<FunctionalType>;
+    readonly value?: Arrayable<FunctionalType>;
+    readonly choices?: readonly VeryPrimitivesTypes[];
+    readonly lazyLoadMethod?: (value: Arrayable<FunctionalType>) => MaybeLazy<Arrayable<FunctionalType>>;
+    readonly valueSelector?: (instanceValue: MaybePromise<Arrayable<FunctionalType>>) => Arrayable<FunctionalType>;
+    readonly validators?: readonly PropertyValidatorComponent[];
+    readonly maxLength?: number;
+    readonly minLength?: number;
+    readonly maxValue?: number;
+    readonly minValue?: number;
+    readonly autoNow?: boolean;
+    readonly fetcher?: (model: Model<any>, primaryKey: PrimaryKeyType) => Promise<any>;
+};
+declare type PropertyConfig = (PropertyConfigContents & DefaultPropertyValidators) | undefined;
+declare type PrimaryKeyPropertyInstanceType = PropertyInstance<string> | PropertyInstance<number>;
+declare type PrimaryKeyType = string | number;
+declare type ModelMethods<T extends FunctionalModel> = ValueIsOfType<T, ModelMethod | ModelMethodTyped<T>>;
+declare type InstanceMethods<T extends FunctionalModel> = ValueIsOfType<T, ModelInstanceMethod | ModelInstanceMethodTyped<T>>;
+declare type ModelDefinition<T extends FunctionalModel> = {
+    readonly getPrimaryKeyName?: () => string;
+    readonly properties: PropertiesList<T> & {
+        readonly id?: PrimaryKeyPropertyInstanceType;
+    };
+    readonly instanceMethods?: InstanceMethods<T>;
+    readonly modelMethods?: ModelMethods<T>;
+    readonly modelValidators?: readonly ModelComponentValidator[];
+};
+declare type Model<T extends FunctionalModel> = {
+    readonly getName: () => string;
+    readonly getPrimaryKeyName: () => string;
+    readonly getModelDefinition: () => ModelDefinition<T>;
+    readonly getPrimaryKey: (t: ModelInstanceInputData<T>) => PrimaryKeyType;
+    readonly create: (data: ModelInstanceInputData<T> & {
+        readonly id?: PrimaryKeyType;
+    }) => ModelInstance<T>;
+    readonly methods: ModelMethodGetters<T>;
+};
+declare type ReferenceFunctions = {
+    readonly [s: string]: () => ReferenceValueType<any>;
+};
+declare type PropertyValidators = {
+    readonly [s: string]: PropertyValidator;
+};
+declare type ModelInstance<T extends FunctionalModel> = {
+    readonly get: PropertyGetters<T> & {
+        readonly id: () => MaybePromise<PrimaryKeyType>;
+    };
+    readonly methods: InstanceMethodGetters<T>;
+    readonly references: ReferenceFunctions;
+    readonly toObj: toObj;
+    readonly getPrimaryKeyName: () => string;
+    readonly getPrimaryKey: () => PrimaryKeyType;
+    readonly validators: PropertyValidators;
+    readonly validate: (options?: {}) => Promise<ModelErrors>;
+    readonly getModel: () => Model<T>;
+};
+declare type ModelMethodTyped<T extends FunctionalModel> = (model: Model<T>, args?: readonly any[]) => any;
+declare type ModelMethod = ModelMethodTyped<any>;
+declare type ModelMethodClient = (...args: readonly any[]) => any;
+declare type ModelInstanceMethodTyped<T extends FunctionalModel> = (instance: ModelInstance<T>, args?: readonly any[]) => any;
+declare type ModelInstanceMethod = ModelInstanceMethodTyped<any>;
+declare type ModelInstanceMethodClient = (...args: readonly any[]) => any;
+declare type ModelOptions = {
+    readonly instanceCreatedCallback: Nullable<Arrayable<(instance: ModelInstance<any>) => void>>;
+};
+declare type OptionalModelOptions = {
+    readonly instanceCreatedCallback?: Nullable<Arrayable<(instance: ModelInstance<any>) => void>>;
+} | undefined;
+export { MaybeFunction, Maybe, MaybePromise, Nullable, Arrayable, MaybeLazy, JsonAble, toObj, ModelInstance, Model, PropertyValidatorComponent, PropertyValidatorComponentSync, PropertyValidatorComponentAsync, PropertyValidatorComponentType, PropertyValidator, ModelComponentValidator, PropertyInstance, PropertyConfig, FunctionalType, ValueGetter, ReferenceValueType, ModelDefinition, ModelOptions, ModelMethod, OptionalModelOptions, ReferencePropertyInstance, PropertyGetters, PropertyValidators, PropertyValidatorComponentTypeAdvanced, ModelInstanceMethod, ModelInstanceMethodTyped, FunctionalModel, ModelInstanceInputData, ModelMethodTyped, ModelMethodGetters, InstanceMethodGetters, ReferenceFunctions, ModelErrors, MaybeEmpty, PrimaryKeyType, };

package/src/interfaces.js

@@ -0,0 +1,5 @@
+"use strict";
+/* eslint-disable no-unused-vars */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-enable no-unused-vars */
+//# sourceMappingURL=interfaces.js.map

package/src/interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../src/interfaces.ts"],"names":[],"mappings":";AAAA,mCAAmC;;AAkUnC,kCAAkC"}

package/src/lazy.d.ts

@@ -0,0 +1,2 @@
+declare const lazyValue: (method: Function) => (...args: readonly any[]) => Promise<any>;
+export { lazyValue };

package/src/lazy.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyValue = void 0;
+const async_lock_1 = __importDefault(require("async-lock"));
+const utils_1 = require("./utils");
+const lazyValue = (method) => {
+    const key = (0, utils_1.createUuid)();
+    const lock = new async_lock_1.default();
+    /* eslint-disable functional/no-let */
+    let value = undefined;
+    let called = false;
+    return (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        return lock.acquire(key, () => __awaiter(void 0, void 0, void 0, function* () {
+            if (!called) {
+                called = true;
+                value = yield method(...args);
+                // eslint-disable-next-line require-atomic-updates
+            }
+            return value;
+        }));
+    });
+    /* eslint-enable functional/no-let */
+};
+exports.lazyValue = lazyValue;
+//# sourceMappingURL=lazy.js.map

package/src/lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.js","sourceRoot":"","sources":["../../src/lazy.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,4DAAkC;AAClC,mCAAoC;AAEpC,MAAM,SAAS,GAAG,CAAC,MAAgB,EAAE,EAAE;IACrC,MAAM,GAAG,GAAG,IAAA,kBAAU,GAAE,CAAA;IACxB,MAAM,IAAI,GAAG,IAAI,oBAAS,EAAE,CAAA;IAC5B,sCAAsC;IACtC,IAAI,KAAK,GAAQ,SAAS,CAAA;IAC1B,IAAI,MAAM,GAAG,KAAK,CAAA;IAClB,OAAO,CAAO,GAAG,IAAoB,EAAE,EAAE;QACvC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,GAAS,EAAE;YAClC,IAAI,CAAC,MAAM,EAAE;gBACX,MAAM,GAAG,IAAI,CAAA;gBACb,KAAK,GAAG,MAAM,MAAM,CAAC,GAAG,IAAI,CAAC,CAAA;gBAC7B,kDAAkD;aACnD;YAED,OAAO,KAAK,CAAA;QACd,CAAC,CAAA,CAAC,CAAA;IACJ,CAAC,CAAA,CAAA;IACD,qCAAqC;AACvC,CAAC,CAAA;AAEQ,8BAAS"}

package/src/methods.d.ts

@@ -0,0 +1,4 @@
+import { ModelInstanceMethodTyped, ModelInstance, FunctionalModel, Model, ModelMethodTyped } from './interfaces';
+declare const WrapperInstanceMethod: <T extends FunctionalModel>(method: (instance: ModelInstance<T>, args?: readonly any[] | undefined) => any) => ModelInstanceMethodTyped<T>;
+declare const WrapperModelMethod: <T extends FunctionalModel>(method: (model: Model<T>, args?: readonly any[] | undefined) => any) => ModelMethodTyped<T>;
+export { WrapperInstanceMethod, WrapperModelMethod };

package/src/methods.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrapperModelMethod = exports.WrapperInstanceMethod = void 0;
+const WrapperInstanceMethod = (method) => {
+    const r = (instance, ...args) => {
+        return method(instance, ...args);
+    };
+    return r;
+};
+exports.WrapperInstanceMethod = WrapperInstanceMethod;
+const WrapperModelMethod = (method) => {
+    const r = (model, ...args) => {
+        return method(model, ...args);
+    };
+    return r;
+};
+exports.WrapperModelMethod = WrapperModelMethod;
+//# sourceMappingURL=methods.js.map

package/src/methods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.js","sourceRoot":"","sources":["../../src/methods.ts"],"names":[],"mappings":";;;AAQA,MAAM,qBAAqB,GAAG,CAC5B,MAAkE,EAClE,EAAE;IACF,MAAM,CAAC,GAAgC,CACrC,QAA0B,EAC1B,GAAG,IAAoB,EACvB,EAAE;QACF,OAAO,MAAM,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,CAAA;IAClC,CAAC,CAAA;IACD,OAAO,CAAC,CAAA;AACV,CAAC,CAAA;AAWQ,sDAAqB;AAT9B,MAAM,kBAAkB,GAAG,CACzB,MAAuD,EACvD,EAAE;IACF,MAAM,CAAC,GAAwB,CAAC,KAAe,EAAE,GAAG,IAAoB,EAAE,EAAE;QAC1E,OAAO,MAAM,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAA;IAC/B,CAAC,CAAA;IACD,OAAO,CAAC,CAAA;AACV,CAAC,CAAA;AAE+B,gDAAkB"}

package/src/models.d.ts

@@ -0,0 +1,3 @@
+import { Model, ModelDefinition, OptionalModelOptions, FunctionalModel } from './interfaces';
+declare const BaseModel: <T extends FunctionalModel>(modelName: string, modelDefinition: ModelDefinition<T>, options?: OptionalModelOptions) => Model<T>;
+export { BaseModel };

package/src/models.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseModel = void 0;
+const merge_1 = __importDefault(require("lodash/merge"));
+const serialization_1 = require("./serialization");
+const validation_1 = require("./validation");
+const properties_1 = require("./properties");
+const _defaultOptions = () => ({
+    instanceCreatedCallback: null,
+});
+const _convertOptions = (options) => {
+    const r = (0, merge_1.default)({}, _defaultOptions(), options);
+    return r;
+};
+const _createModelDefWithPrimaryKey = (keyToProperty) => {
+    return {
+        getPrimaryKeyName: () => 'id',
+        modelMethods: keyToProperty.modelMethods,
+        instanceMethods: keyToProperty.instanceMethods,
+        properties: Object.assign({ id: (0, properties_1.UniqueId)({ required: true }) }, keyToProperty.properties),
+        modelValidators: keyToProperty.modelValidators,
+    };
+};
+const BaseModel = (modelName, modelDefinition, 
+//keyToProperty: IModelDefinition2<T>,
+options) => {
+    /*
+     * This non-functional approach is specifically used to
+     * allow instances to be able to refer back to its parent without
+     * having to duplicate it for every instance.
+     * This is set at the very end and returned, so it can be referenced
+     * throughout instance methods.
+     */
+    // eslint-disable-next-line functional/no-let
+    let model = null;
+    const theOptions = _convertOptions(options);
+    modelDefinition = !modelDefinition.getPrimaryKeyName
+        ? _createModelDefWithPrimaryKey(modelDefinition)
+        : modelDefinition;
+    // @ts-ignore
+    const getPrimaryKeyName = () => modelDefinition.getPrimaryKeyName();
+    const getPrimaryKey = (t) => 
+    // @ts-ignore
+    t[getPrimaryKeyName()];
+    const create = (instanceValues) => {
+        // eslint-disable-next-line functional/no-let
+        let instance = null;
+        const startingInternals = {
+            get: {},
+            validators: {},
+            references: {},
+        };
+        const loadedInternals = Object.entries(modelDefinition.properties).reduce((acc, [key, property]) => {
+            // @ts-ignore
+            const propertyGetter = property.createGetter(instanceValues[key]);
+            // @ts-ignore
+            const propertyValidator = property.getValidator(propertyGetter);
+            const fleshedOutInstanceProperties = {
+                get: {
+                    [key]: propertyGetter,
+                },
+                validators: {
+                    [key]: propertyValidator,
+                },
+            };
+            const asReferenced = property;
+            const referencedProperty = asReferenced.getReferencedId
+                ? {
+                    references: {
+                        [key]: () => asReferenced.getReferencedId(
+                        // @ts-ignore
+                        instanceValues[key]),
+                    },
+                }
+                : {};
+            return (0, merge_1.default)(acc, fleshedOutInstanceProperties, referencedProperty);
+        }, startingInternals);
+        const methods = Object.entries(modelDefinition.instanceMethods || {}).reduce((acc, [key, func]) => {
+            return (0, merge_1.default)(acc, {
+                [key]: (...args) => {
+                    return func(instance, ...args);
+                },
+            });
+        }, {});
+        const getModel = () => model;
+        const toObj = (0, serialization_1.toJsonAble)(loadedInternals.get);
+        const validate = (options = {}) => {
+            return (0, validation_1.createModelValidator)(loadedInternals.validators, modelDefinition.modelValidators || [])(instance, options);
+        };
+        instance = (0, merge_1.default)(loadedInternals, {
+            getModel,
+            toObj,
+            getPrimaryKey: () => getPrimaryKey(instanceValues),
+            getPrimaryKeyName,
+            validate,
+            methods,
+        });
+        if (theOptions.instanceCreatedCallback) {
+            const toCall = Array.isArray(theOptions.instanceCreatedCallback)
+                ? theOptions.instanceCreatedCallback
+                : [theOptions.instanceCreatedCallback];
+            toCall.map(func => func(instance));
+        }
+        return instance;
+    };
+    const fleshedOutModelFunctions = Object.entries(modelDefinition.modelMethods || {}).reduce((acc, [key, func]) => {
+        return (0, merge_1.default)(acc, {
+            [key]: (...args) => {
+                return func(model, ...args);
+            },
+        });
+    }, {});
+    // This sets the model that is used by the instances later.
+    model = (0, merge_1.default)({}, {
+        create,
+        getName: () => modelName,
+        getModelDefinition: () => modelDefinition,
+        getPrimaryKeyName,
+        getPrimaryKey,
+        methods: fleshedOutModelFunctions,
+    });
+    return model;
+};
+exports.BaseModel = BaseModel;
+//# sourceMappingURL=models.js.map

package/src/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../src/models.ts"],"names":[],"mappings":"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"}

package/src/properties.d.ts

@@ -0,0 +1,16 @@
+import { MaybeEmpty, Model, PropertyInstance, FunctionalType, PropertyConfig, MaybeFunction, Arrayable, ReferencePropertyInstance, FunctionalModel, JsonAble } from './interfaces';
+declare function Property<T extends Arrayable<FunctionalType>>(type: string, config?: PropertyConfig, additionalMetadata?: {}): PropertyInstance<T>;
+declare const DateProperty: (config?: PropertyConfig, additionalMetadata?: {}) => PropertyInstance<MaybeEmpty<Date>>;
+declare const ArrayProperty: <T extends FunctionalType>(config?: {}, additionalMetadata?: {}) => PropertyInstance<readonly T[]>;
+declare const ObjectProperty: (config?: {}, additionalMetadata?: {}) => PropertyInstance<{
+    readonly [s: string]: JsonAble;
+}>;
+declare const TextProperty: (config?: PropertyConfig, additionalMetadata?: {}) => PropertyInstance<MaybeEmpty<string>>;
+declare const IntegerProperty: (config?: PropertyConfig, additionalMetadata?: {}) => PropertyInstance<MaybeEmpty<number>>;
+declare const NumberProperty: (config?: PropertyConfig, additionalMetadata?: {}) => PropertyInstance<MaybeEmpty<number>>;
+declare const ConstantValueProperty: (value: string, config?: PropertyConfig, additionalMetadata?: {}) => PropertyInstance<MaybeEmpty<string>>;
+declare const EmailProperty: (config?: PropertyConfig, additionalMetadata?: {}) => PropertyInstance<MaybeEmpty<string>>;
+declare const BooleanProperty: (config?: PropertyConfig, additionalMetadata?: {}) => PropertyInstance<MaybeEmpty<boolean>>;
+declare const UniqueId: (config?: PropertyConfig, additionalMetadata?: {}) => PropertyInstance<string>;
+declare const ReferenceProperty: <T extends FunctionalModel>(model: MaybeFunction<Model<T>>, config?: PropertyConfig, additionalMetadata?: {}) => ReferencePropertyInstance<T>;
+export { Property, UniqueId, DateProperty, ArrayProperty, ReferenceProperty, IntegerProperty, TextProperty, ConstantValueProperty, NumberProperty, ObjectProperty, EmailProperty, BooleanProperty, };