@goatlab/fluent 0.7.39 → 0.7.41

package/dist/core/Loopback/metadata.d.ts

@@ -0,0 +1,16 @@
+import { InspectionOptions, MetadataAccessor, MetadataMap } from '@loopback/metadata';
+import { ModelDefinition, ModelDefinitionSyntax, PropertyDefinition } from './model';
+export declare const MODEL_KEY: MetadataAccessor<Partial<ModelDefinitionSyntax>, ClassDecorator>;
+export declare const MODEL_PROPERTIES_KEY: MetadataAccessor<PropertyDefinition, PropertyDecorator>;
+export declare const MODEL_WITH_PROPERTIES_KEY: MetadataAccessor<ModelDefinition, ClassDecorator>;
+export type PropertyMap = MetadataMap<Partial<PropertyDefinition>>;
+export declare class ModelMetadataHelper {
+    /**
+     * A utility function to simplify retrieving metadata from a target model and
+     * its properties.
+     * @param target - The class from which to retrieve metadata.
+     * @param options - An options object for the MetadataInspector to customize
+     * the output of the metadata retrieval functions.
+     */
+    static getModelMetadata(target: Function, options?: InspectionOptions): ModelDefinition | {};
+}

package/dist/core/Loopback/metadata.js

@@ -0,0 +1,49 @@
+"use strict";
+// Copyright IBM Corp. 2017,2020. All Rights Reserved.
+// Node module: @loopback/repository
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelMetadataHelper = exports.MODEL_WITH_PROPERTIES_KEY = exports.MODEL_PROPERTIES_KEY = exports.MODEL_KEY = void 0;
+const metadata_1 = require("@loopback/metadata");
+const model_1 = require("./model");
+const RELATIONS_KEY = 'loopback:relations';
+exports.MODEL_KEY = metadata_1.MetadataAccessor.create('loopback:model');
+exports.MODEL_PROPERTIES_KEY = metadata_1.MetadataAccessor.create('loopback:model-properties');
+exports.MODEL_WITH_PROPERTIES_KEY = metadata_1.MetadataAccessor.create('loopback:model-and-properties');
+class ModelMetadataHelper {
+    /**
+     * A utility function to simplify retrieving metadata from a target model and
+     * its properties.
+     * @param target - The class from which to retrieve metadata.
+     * @param options - An options object for the MetadataInspector to customize
+     * the output of the metadata retrieval functions.
+     */
+    static getModelMetadata(target, options) {
+        const classDef = metadata_1.MetadataInspector.getClassMetadata(exports.MODEL_WITH_PROPERTIES_KEY, target, 
+        // https://github.com/loopbackio/loopback-next/issues/4721
+        // The `target` can be a subclass for a base model
+        { ...options, ownMetadataOnly: true });
+        // Return the cached value, if it exists.
+        // XXX(kjdelisle): If we're going to support dynamic updates, then this
+        // will be problematic in the future, since it will never update.
+        if (classDef) {
+            return classDef;
+        }
+        const modelMeta = metadata_1.MetadataInspector.getClassMetadata(exports.MODEL_KEY, target, options);
+        if (!modelMeta) {
+            return {};
+        }
+        // sets the metadata to a dedicated key if cached value does not exist
+        // set ModelDefinition properties if they don't already exist
+        const meta = new model_1.ModelDefinition({ ...modelMeta });
+        // set properties lost from creating instance of ModelDefinition
+        Object.assign(meta, modelMeta);
+        meta.properties = Object.assign(meta.properties, metadata_1.MetadataInspector.getAllPropertyMetadata(exports.MODEL_PROPERTIES_KEY, target.prototype, options));
+        meta.relations = Object.assign(meta.relations, metadata_1.MetadataInspector.getAllPropertyMetadata(RELATIONS_KEY, target.prototype, options));
+        metadata_1.MetadataInspector.defineMetadata(exports.MODEL_WITH_PROPERTIES_KEY.key, meta, target);
+        return meta;
+    }
+}
+exports.ModelMetadataHelper = ModelMetadataHelper;
+//# sourceMappingURL=metadata.js.map

package/dist/core/Loopback/metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.js","sourceRoot":"","sources":["../../../src/core/Loopback/metadata.ts"],"names":[],"mappings":";AAAA,sDAAsD;AACtD,oCAAoC;AACpC,+CAA+C;AAC/C,gEAAgE;;;AAEhE,iDAK2B;AAC3B,mCAKgB;AAEhB,MAAM,aAAa,GAAG,oBAAoB,CAAA;AAE7B,QAAA,SAAS,GAAG,2BAAgB,CAAC,MAAM,CAG9C,gBAAgB,CAAC,CAAA;AAEN,QAAA,oBAAoB,GAAG,2BAAgB,CAAC,MAAM,CAGzD,2BAA2B,CAAC,CAAA;AAEjB,QAAA,yBAAyB,GAAG,2BAAgB,CAAC,MAAM,CAG9D,+BAA+B,CAAC,CAAA;AAIlC,MAAa,mBAAmB;IAC9B;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,MAAgB,EAChB,OAA2B;QAE3B,MAAM,QAAQ,GAAG,4BAAiB,CAAC,gBAAgB,CACjD,iCAAyB,EACzB,MAAM;QACN,0DAA0D;QAC1D,kDAAkD;QAClD,EAAE,GAAG,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,CACtC,CAAA;QACD,yCAAyC;QACzC,uEAAuE;QACvE,iEAAiE;QACjE,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,QAAQ,CAAA;QACjB,CAAC;QACD,MAAM,SAAS,GAAG,4BAAiB,CAAC,gBAAgB,CAClD,iBAAS,EACT,MAAM,EACN,OAAO,CACR,CAAA;QACD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO,EAAE,CAAA;QACX,CAAC;QACD,sEAAsE;QAEtE,6DAA6D;QAC7D,MAAM,IAAI,GAAG,IAAI,uBAAe,CAAC,EAAE,GAAG,SAAS,EAAE,CAAC,CAAA;QAElD,gEAAgE;QAChE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;QAE9B,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,MAAM,CAChB,IAAI,CAAC,UAAU,EAC5B,4BAAiB,CAAC,sBAAsB,CACtC,4BAAoB,EACpB,MAAM,CAAC,SAAS,EAChB,OAAO,CACR,CACF,CAAA;QAED,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,CACL,IAAI,CAAC,SAAS,EACrC,4BAAiB,CAAC,sBAAsB,CACtC,aAAa,EACb,MAAM,CAAC,SAAS,EAChB,OAAO,CACR,CACF,CAAA;QAED,4BAAiB,CAAC,cAAc,CAC9B,iCAAyB,CAAC,GAAG,EAC7B,IAAI,EACJ,MAAM,CACP,CAAA;QACD,OAAO,IAAI,CAAA;IACb,CAAC;CACF;AAlED,kDAkEC"}

package/dist/core/Loopback/model.d.ts

@@ -0,0 +1,233 @@
+import { SchemaObject as JsonSchema } from 'openapi3-ts/oas30';
+import { AnyObject, DataObject, Options, PrototypeOf } from './common-types';
+import { BelongsToDefinition, HasManyDefinition, HasOneDefinition, RelationMetadata } from './relation.types';
+import { TypeResolver } from './type-resolver';
+import { Type } from './type';
+/**
+ * This module defines the key classes representing building blocks for Domain
+ * Driven Design.
+ * See https://en.wikipedia.org/wiki/Domain-driven_design#Building_blocks
+ */
+export interface JsonSchemaWithExtensions extends JsonSchema {
+    [attributes: string]: any;
+}
+export type PropertyType = string | Function | object | Type<any> | TypeResolver<Model>;
+/**
+ * Property definition for a model
+ */
+export interface PropertyDefinition {
+    type: PropertyType;
+    id?: boolean | number;
+    /**
+     * Used to hide this property from the response body,
+     * adding this property to the hiddenProperties array
+     */
+    hidden?: boolean;
+    json?: PropertyForm;
+    jsonSchema?: JsonSchemaWithExtensions;
+    store?: PropertyForm;
+    itemType?: PropertyType;
+    [attribute: string]: any;
+}
+/**
+ * Defining the settings for a model
+ * See https://loopback.io/doc/en/lb4/Model.html#supported-entries-of-model-definition
+ */
+export interface ModelSettings {
+    /**
+     * Description of the model
+     */
+    description?: string;
+    /**
+     * Prevent clients from setting the auto-generated ID value manually
+     */
+    forceId?: boolean;
+    /**
+     * Hides properties from response bodies
+     */
+    hiddenProperties?: string[];
+    /**
+     * Scope enables you to set a scope that will apply to every query made by the model's repository
+     */
+    scope?: object;
+    /**
+     * Specifies whether the model accepts only predefined properties or not
+     */
+    strict?: boolean | 'filter';
+    [name: string]: any;
+}
+/**
+ * See https://github.com/loopbackio/loopback-datasource-juggler/issues/432
+ */
+export interface PropertyForm {
+    in?: boolean;
+    out?: boolean;
+    name?: string;
+}
+/**
+ * A key-value map describing model relations.
+ * A relation name is used as the key, a relation definition is the value.
+ */
+export type RelationDefinitionMap = {
+    [relationName: string]: RelationMetadata;
+};
+/**
+ * DSL for building a model definition.
+ */
+export interface ModelDefinitionSyntax {
+    name: string;
+    properties?: {
+        [name: string]: PropertyDefinition | PropertyType;
+    };
+    settings?: ModelSettings;
+    relations?: RelationDefinitionMap;
+    jsonSchema?: JsonSchemaWithExtensions;
+    [attribute: string]: any;
+}
+/**
+ * Definition for a model
+ */
+export declare class ModelDefinition {
+    readonly name: string;
+    properties: {
+        [name: string]: PropertyDefinition;
+    };
+    settings: ModelSettings;
+    relations: RelationDefinitionMap;
+    [attribute: string]: any;
+    constructor(nameOrDef: string | ModelDefinitionSyntax);
+    /**
+     * Add a property
+     * @param name - Property definition or name (string)
+     * @param definitionOrType - Definition or property type
+     */
+    addProperty(name: string, definitionOrType: PropertyDefinition | PropertyType): this;
+    /**
+     * Add a setting
+     * @param name - Setting name
+     * @param value - Setting value
+     */
+    addSetting(name: string, value: any): this;
+    /**
+     * Define a new relation.
+     * @param definition - The definition of the new relation.
+     */
+    addRelation(definition: RelationMetadata): this;
+    /**
+     * Define a new belongsTo relation.
+     * @param name - The name of the belongsTo relation.
+     * @param definition - The definition of the belongsTo relation.
+     */
+    belongsTo(name: string, definition: Omit<BelongsToDefinition, 'name' | 'type' | 'targetsMany'>): this;
+    /**
+     * Define a new hasOne relation.
+     * @param name - The name of the hasOne relation.
+     * @param definition - The definition of the hasOne relation.
+     */
+    hasOne(name: string, definition: Omit<HasOneDefinition, 'name' | 'type' | 'targetsMany'>): this;
+    /**
+     * Define a new hasMany relation.
+     * @param name - The name of the hasMany relation.
+     * @param definition - The definition of the hasMany relation.
+     */
+    hasMany(name: string, definition: Omit<HasManyDefinition, 'name' | 'type' | 'targetsMany'>): this;
+    /**
+     * Get an array of names of ID properties, which are specified in
+     * the model settings or properties with `id` attribute.
+     *
+     * @example
+     * ```ts
+     * {
+     *   settings: {
+     *     id: ['id']
+     *   }
+     *   properties: {
+     *     id: {
+     *       type: 'string',
+     *       id: true
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    idProperties(): string[];
+}
+/**
+ * Base class for models
+ */
+export declare class Model {
+    static get modelName(): string;
+    static definition: ModelDefinition;
+    /**
+     * Serialize into a plain JSON object
+     */
+    toJSON(): Object;
+    /**
+     * Convert to a plain object as DTO
+     *
+     * If `ignoreUnknownProperty` is set to false, convert all properties in the
+     * model instance, otherwise only convert the ones defined in the model
+     * definitions.
+     *
+     * See function `asObject` for each property's conversion rules.
+     */
+    toObject(options?: Options): Object;
+    constructor(data?: DataObject<Model>);
+}
+export interface Persistable {
+}
+/**
+ * Base class for value objects - An object that contains attributes but has no
+ * conceptual identity. They should be treated as immutable.
+ */
+export declare abstract class ValueObject extends Model implements Persistable {
+}
+/**
+ * Base class for entities which have unique ids
+ */
+export declare class Entity extends Model implements Persistable {
+    /**
+     * Get the names of identity properties (primary keys).
+     */
+    static getIdProperties(): string[];
+    /**
+     * Get the identity value for a given entity instance or entity data object.
+     *
+     * @param entityOrData - The data object for which to determine the identity
+     * value.
+     */
+    static getIdOf(entityOrData: AnyObject): any;
+    /**
+     * Get the identity value. If the identity is a composite key, returns
+     * an object.
+     */
+    getId(): any;
+    /**
+     * Get the identity as an object, such as `{id: 1}` or
+     * `{schoolId: 1, studentId: 2}`
+     */
+    getIdObject(): Object;
+    /**
+     * Build the where object for the given id
+     * @param id - The id value
+     */
+    static buildWhereForId(id: any): any;
+}
+/**
+ * Domain events
+ */
+export declare class Event {
+    source: any;
+    type: string;
+}
+export type EntityData = DataObject<Entity>;
+export type EntityResolver<T extends Entity> = TypeResolver<T, typeof Entity>;
+/**
+ * Check model data for navigational properties linking to related models.
+ * Throw a descriptive error if any such property is found.
+ *
+ * @param modelClass Model constructor, e.g. `Product`.
+ * @param entityData  Model instance or a plain-data object,
+ * e.g. `{name: 'pen'}`.
+ */
+export declare function rejectNavigationalPropertiesInData<M extends typeof Entity>(modelClass: M, data: DataObject<PrototypeOf<M>>): void;

package/dist/core/Loopback/model.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = exports.Entity = exports.ValueObject = exports.Model = exports.ModelDefinition = void 0;
+exports.rejectNavigationalPropertiesInData = rejectNavigationalPropertiesInData;
+const relation_types_1 = require("./relation.types");
+/**
+ * Definition for a model
+ */
+class ModelDefinition {
+    name;
+    properties;
+    settings;
+    relations;
+    constructor(nameOrDef) {
+        if (typeof nameOrDef === 'string') {
+            nameOrDef = { name: nameOrDef };
+        }
+        const { name, properties, settings, relations } = nameOrDef;
+        this.name = name;
+        this.properties = {};
+        if (properties) {
+            for (const p in properties) {
+                const prop = properties[p];
+                if (prop !== undefined) {
+                    this.addProperty(p, prop);
+                }
+            }
+        }
+        this.settings = settings ?? new Map();
+        this.relations = relations ?? {};
+    }
+    /**
+     * Add a property
+     * @param name - Property definition or name (string)
+     * @param definitionOrType - Definition or property type
+     */
+    addProperty(name, definitionOrType) {
+        const definition = definitionOrType.type
+            ? definitionOrType
+            : { type: definitionOrType };
+        if (definition.id === true &&
+            definition.generated === true &&
+            definition.type !== undefined &&
+            definition.useDefaultIdType === undefined) {
+            definition.useDefaultIdType = false;
+        }
+        this.properties[name] = definition;
+        return this;
+    }
+    /**
+     * Add a setting
+     * @param name - Setting name
+     * @param value - Setting value
+     */
+    addSetting(name, value) {
+        this.settings[name] = value;
+        return this;
+    }
+    /**
+     * Define a new relation.
+     * @param definition - The definition of the new relation.
+     */
+    addRelation(definition) {
+        this.relations[definition.name] = definition;
+        return this;
+    }
+    /**
+     * Define a new belongsTo relation.
+     * @param name - The name of the belongsTo relation.
+     * @param definition - The definition of the belongsTo relation.
+     */
+    belongsTo(name, definition) {
+        const meta = {
+            ...definition,
+            name,
+            type: relation_types_1.RelationType.belongsTo,
+            targetsMany: false
+        };
+        return this.addRelation(meta);
+    }
+    /**
+     * Define a new hasOne relation.
+     * @param name - The name of the hasOne relation.
+     * @param definition - The definition of the hasOne relation.
+     */
+    hasOne(name, definition) {
+        const meta = {
+            ...definition,
+            name,
+            type: relation_types_1.RelationType.hasOne,
+            targetsMany: false
+        };
+        return this.addRelation(meta);
+    }
+    /**
+     * Define a new hasMany relation.
+     * @param name - The name of the hasMany relation.
+     * @param definition - The definition of the hasMany relation.
+     */
+    hasMany(name, definition) {
+        const meta = {
+            ...definition,
+            name,
+            type: relation_types_1.RelationType.hasMany,
+            targetsMany: true
+        };
+        return this.addRelation(meta);
+    }
+    /**
+     * Get an array of names of ID properties, which are specified in
+     * the model settings or properties with `id` attribute.
+     *
+     * @example
+     * ```ts
+     * {
+     *   settings: {
+     *     id: ['id']
+     *   }
+     *   properties: {
+     *     id: {
+     *       type: 'string',
+     *       id: true
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    idProperties() {
+        if (typeof this.settings.id === 'string') {
+            return [this.settings.id];
+        }
+        if (Array.isArray(this.settings.id)) {
+            return this.settings.id;
+        }
+        const idProps = Object.keys(this.properties).filter(prop => this.properties[prop]?.id);
+        return idProps;
+    }
+}
+exports.ModelDefinition = ModelDefinition;
+function asJSON(value) {
+    if (value == null)
+        return value;
+    if (typeof value.toJSON === 'function') {
+        return value.toJSON();
+    }
+    // Handle arrays
+    if (Array.isArray(value)) {
+        return value.map(item => asJSON(item));
+    }
+    return value;
+}
+/**
+ * Convert a value to a plain object as DTO.
+ *
+ * - The prototype of the value in primitive types are preserved,
+ *   like `Date`, `ObjectId`.
+ * - If the value is an instance of custom model, call `toObject` to convert.
+ * - If the value is an array, convert each element recursively.
+ *
+ * @param value the value to convert
+ * @param options the options
+ */
+function asObject(value, options) {
+    if (value == null)
+        return value;
+    if (typeof value.toObject === 'function') {
+        return value.toObject(options);
+    }
+    if (Array.isArray(value)) {
+        return value.map(item => asObject(item, options));
+    }
+    return value;
+}
+/**
+ * Base class for models
+ */
+// tslint:disable-next-line: max-classes-per-file
+class Model {
+    static get modelName() {
+        return this.definition?.name || this.name;
+    }
+    static definition;
+    /**
+     * Serialize into a plain JSON object
+     */
+    toJSON() {
+        const def = this.constructor.definition;
+        if (def == null || def.settings.strict === false) {
+            return this.toObject({ ignoreUnknownProperties: false });
+        }
+        const copyPropertyAsJson = (key) => {
+            const val = asJSON(this[key]);
+            if (val !== undefined) {
+                json[key] = val;
+            }
+        };
+        const json = {};
+        const hiddenProperties = def.settings.hiddenProperties || [];
+        for (const p in def.properties) {
+            if (p in this && !hiddenProperties.includes(p)) {
+                copyPropertyAsJson(p);
+            }
+        }
+        for (const r in def.relations) {
+            const rel = def.relations[r];
+            if (!rel)
+                continue;
+            const relName = rel.name;
+            if (relName in this) {
+                copyPropertyAsJson(relName);
+            }
+        }
+        return json;
+    }
+    /**
+     * Convert to a plain object as DTO
+     *
+     * If `ignoreUnknownProperty` is set to false, convert all properties in the
+     * model instance, otherwise only convert the ones defined in the model
+     * definitions.
+     *
+     * See function `asObject` for each property's conversion rules.
+     */
+    toObject(options) {
+        const def = this.constructor.definition;
+        const obj = {};
+        if (options?.ignoreUnknownProperties === false) {
+            const hiddenProperties = def?.settings.hiddenProperties || [];
+            for (const p in this) {
+                if (!hiddenProperties.includes(p)) {
+                    const val = this[p];
+                    obj[p] = asObject(val, options);
+                }
+            }
+            return obj;
+        }
+        if (def?.relations) {
+            // tslint:disable-next-line: forin
+            for (const r in def.relations) {
+                const rel = def.relations[r];
+                if (!rel)
+                    continue;
+                const relName = rel.name;
+                if (relName in this) {
+                    obj[relName] = asObject(this[relName], {
+                        ...options,
+                        ignoreUnknownProperties: false
+                    });
+                }
+            }
+        }
+        const props = def.properties;
+        const keys = Object.keys(props);
+        // tslint:disable-next-line: forin
+        for (const i in keys) {
+            const propertyName = keys[i];
+            if (!propertyName)
+                continue;
+            const val = this[propertyName];
+            if (val === undefined)
+                continue;
+            obj[propertyName] = asObject(val, options);
+        }
+        return obj;
+    }
+    constructor(data) {
+        Object.assign(this, data);
+    }
+}
+exports.Model = Model;
+/**
+ * Base class for value objects - An object that contains attributes but has no
+ * conceptual identity. They should be treated as immutable.
+ */
+class ValueObject extends Model {
+}
+exports.ValueObject = ValueObject;
+/**
+ * Base class for entities which have unique ids
+ */
+class Entity extends Model {
+    /**
+     * Get the names of identity properties (primary keys).
+     */
+    static getIdProperties() {
+        return this.definition.idProperties();
+    }
+    /**
+     * Get the identity value for a given entity instance or entity data object.
+     *
+     * @param entityOrData - The data object for which to determine the identity
+     * value.
+     */
+    static getIdOf(entityOrData) {
+        if (typeof entityOrData.getId === 'function') {
+            return entityOrData.getId();
+        }
+        const idName = this.getIdProperties()[0];
+        if (!idName)
+            return undefined;
+        return entityOrData[idName];
+    }
+    /**
+     * Get the identity value. If the identity is a composite key, returns
+     * an object.
+     */
+    getId() {
+        const { definition } = this.constructor;
+        const idProps = definition.idProperties();
+        if (idProps.length === 1) {
+            const firstId = idProps[0];
+            if (!firstId)
+                return undefined;
+            return this[firstId];
+        }
+        if (!idProps.length) {
+            throw new Error(`Invalid Entity ${this.constructor.name}:` +
+                'missing primary key (id) property');
+        }
+        return this.getIdObject();
+    }
+    /**
+     * Get the identity as an object, such as `{id: 1}` or
+     * `{schoolId: 1, studentId: 2}`
+     */
+    getIdObject() {
+        const { definition } = this.constructor;
+        const idProps = definition.idProperties();
+        const idObj = {};
+        for (const idProp of idProps) {
+            idObj[idProp] = this[idProp];
+        }
+        return idObj;
+    }
+    /**
+     * Build the where object for the given id
+     * @param id - The id value
+     */
+    static buildWhereForId(id) {
+        const where = {};
+        const idProps = this.definition.idProperties();
+        if (idProps.length === 1) {
+            const firstId = idProps[0];
+            if (firstId) {
+                where[firstId] = id;
+            }
+        }
+        else {
+            for (const idProp of idProps) {
+                where[idProp] = id[idProp];
+            }
+        }
+        return where;
+    }
+}
+exports.Entity = Entity;
+/**
+ * Domain events
+ */
+class Event {
+    source;
+    type;
+}
+exports.Event = Event;
+/**
+ * Check model data for navigational properties linking to related models.
+ * Throw a descriptive error if any such property is found.
+ *
+ * @param modelClass Model constructor, e.g. `Product`.
+ * @param entityData  Model instance or a plain-data object,
+ * e.g. `{name: 'pen'}`.
+ */
+function rejectNavigationalPropertiesInData(modelClass, data) {
+    const def = modelClass.definition;
+    const props = def.properties;
+    for (const r in def.relations) {
+        const rel = def.relations[r];
+        if (!rel)
+            continue;
+        const relName = rel.name;
+        if (!(relName in data))
+            continue;
+        let msg = 'Navigational properties are not allowed in model data ' +
+            `(model "${modelClass.modelName}" property "${relName}"), ` +
+            'please remove it.';
+        if (relName in props) {
+            msg +=
+                ' The error might be invoked by belongsTo relations, please make' +
+                    ' sure the relation name is not the same as the property name.';
+        }
+        throw new Error(msg);
+    }
+}
+//# sourceMappingURL=model.js.map