breeze-client 2.2.1-cjs → 2.2.1

package/esm2022/src/mapping-context.mjs

@@ -0,0 +1,411 @@
+import { core } from './core';
+import { DataType } from './data-type';
+import { EntityState } from './entity-state';
+import { EntityAction } from './entity-action';
+import { EntityType, DataProperty } from './entity-metadata';
+import { MergeStrategy } from './query-options';
+import { EntityQuery } from './entity-query';
+/**
+For use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation.
+@adapter (see [[IDataServiceAdapter]])
+@hidden
+*/
+export class MappingContext {
+    rawValueFn = DataProperty.getRawValueFromServer; // think about passing this in later.
+    constructor(config) {
+        core.extend(this, config, [
+            "query", "entityManager", "dataService", "mergeOptions"
+        ]);
+        // calc'd props
+        this.refMap = {};
+        this.deferredFns = [];
+        this.jsonResultsAdapter = this.dataService.jsonResultsAdapter;
+        this.metadataStore = this.entityManager.metadataStore;
+        this.rawValueFn = DataProperty.getRawValueFromServer; // think about passing this in later.
+    }
+    getUrl() {
+        let query = this.query;
+        if (!query) {
+            throw new Error("query cannot be empty");
+        }
+        let uriString;
+        if (typeof query === 'string') {
+            uriString = query;
+        }
+        else if (query instanceof EntityQuery) {
+            uriString = this.dataService.uriBuilder.buildUri(query, this.metadataStore);
+        }
+        else {
+            throw new Error("unable to recognize query parameter as either a string or an EntityQuery");
+        }
+        return this.dataService.qualifyUrl(uriString);
+    }
+    visitAndMerge(nodes, nodeContext) {
+        let query = this.query;
+        let jra = this.jsonResultsAdapter;
+        nodeContext = nodeContext || {};
+        let that = this;
+        let result = core.map(nodes, function (node) {
+            if (query == null && node.entityAspect) {
+                // don't bother merging a result from a save that was not returned from the server.
+                if (node.entityAspect.entityState.isDeleted()) {
+                    that.entityManager.detachEntity(node);
+                }
+                else {
+                    node.entityAspect.acceptChanges();
+                }
+                return node;
+            }
+            let meta = jra.visitNode(node, that, nodeContext) || {};
+            node = meta.node || node;
+            if (query && nodeContext.nodeType === "root" && !meta.entityType) {
+                meta.entityType = query instanceof EntityQuery && query._getToEntityType && query._getToEntityType(that.metadataStore);
+            }
+            return processMeta(that, node, meta);
+        }, this.mergeOptions.includeDeleted);
+        if (result.filter && !this.mergeOptions.includeDeleted) {
+            // result may have deleted entities because related nodes were processed
+            result = result.filter((x) => x && (!x.entityAspect || !x.entityAspect.entityState.isDeleted()));
+        }
+        return result;
+    }
+    processDeferred() {
+        if (this.deferredFns.length > 0) {
+            this.deferredFns.forEach((fn) => {
+                fn();
+            });
+        }
+    }
+}
+MappingContext.prototype._$typeName = "MappingContext";
+function processMeta(mc, node, meta, assignFn) {
+    // == is deliberate here instead of ===
+    if (meta.ignore || node == null) {
+        return null;
+    }
+    else if (meta.nodeRefId) {
+        let refValue = resolveEntityRef(mc, meta.nodeRefId);
+        if (typeof refValue === "function" && assignFn != null) {
+            mc.deferredFns.push(function () {
+                assignFn(refValue);
+            });
+            return undefined; // deferred and will be set later;
+        }
+        return refValue;
+    }
+    else if (meta.entityType) {
+        let entityType = meta.entityType;
+        if (mc.mergeOptions.noTracking) {
+            node = processNoMerge(mc, entityType, node);
+            if (entityType.noTrackingFn) {
+                node = entityType.noTrackingFn(node, entityType);
+            }
+            if (meta.nodeId) {
+                mc.refMap[meta.nodeId] = node;
+            }
+            return node;
+        }
+        else {
+            if (entityType.isComplexType) {
+                // because we still need to do serverName to client name processing
+                return processNoMerge(mc, entityType, node);
+            }
+            else {
+                return mergeEntity(mc, node, meta);
+            }
+        }
+    }
+    else {
+        if ((!meta.passThru) && typeof node === 'object' && !core.isDate(node)) {
+            node = processAnonType(mc, node);
+        }
+        // updating the refMap for entities is handled by updateEntityRef for entities.
+        if (meta.nodeId) {
+            mc.refMap[meta.nodeId] = node;
+        }
+        return node;
+    }
+}
+function processNoMerge(mc, stype, node) {
+    let result = {};
+    stype.dataProperties.forEach(function (dp) {
+        if (dp.isComplexProperty) {
+            result[dp.name] = core.map(node[dp.nameOnServer], (v) => {
+                return processNoMerge(mc, dp.dataType, v);
+            });
+        }
+        else {
+            result[dp.name] = DataType.parseRawValue(node[dp.nameOnServer], dp.dataType);
+        }
+    });
+    (stype instanceof EntityType) && stype.navigationProperties.forEach((np) => {
+        let nodeContext = { nodeType: "navProp", navigationProperty: np };
+        visitNode(node[np.nameOnServer], mc, nodeContext, result, np.name);
+    });
+    return result;
+}
+function processAnonType(mc, node) {
+    // node is guaranteed to be an object by this point, i.e. not a scalar
+    let keyFn = mc.metadataStore.namingConvention.serverPropertyNameToClient;
+    let result = {};
+    core.objectForEach(node, function (key, value) {
+        let newKey = keyFn(key);
+        let nodeContext = { nodeType: "anonProp", propertyName: newKey };
+        visitNode(value, mc, nodeContext, result, newKey);
+    });
+    return result;
+}
+function visitNode(node, mc, nodeContext, result, key) {
+    let jra = mc.jsonResultsAdapter;
+    let meta = jra.visitNode(node, mc, nodeContext) || {};
+    // allows visitNode to change the value;
+    node = meta.node || node;
+    if (meta.ignore)
+        return;
+    if (meta.passThru)
+        return node;
+    if (Array.isArray(node)) {
+        nodeContext.nodeType = nodeContext.nodeType + "Item";
+        result[key] = node.map(function (v, ix) {
+            meta = jra.visitNode(v, mc, nodeContext) || {};
+            v = meta.node || v;
+            return processMeta(mc, v, meta, function (refValue) {
+                result[key][ix] = refValue();
+            });
+        });
+    }
+    else {
+        result[key] = processMeta(mc, node, meta, function (refValue) {
+            result[key] = refValue();
+        });
+    }
+}
+function resolveEntityRef(mc, nodeRefId) {
+    let entity = mc.refMap[nodeRefId];
+    if (entity === undefined) {
+        return function () {
+            return mc.refMap[nodeRefId];
+        };
+    }
+    else {
+        return entity;
+    }
+}
+function updateEntityRef(mc, targetEntity, node) {
+    let nodeId = node._$meta.nodeId;
+    if (!nodeId && node._$meta.extraMetadata) {
+        // odata case.  refMap isn't really used, but is returned as data.retrievedEntities, so we populated it anyway.
+        nodeId = node._$meta.extraMetadata.uriKey;
+    }
+    if (nodeId != null) {
+        mc.refMap[nodeId] = targetEntity;
+    }
+}
+// can return null for a deleted entity if includeDeleted == false
+function mergeEntity(mc, node, meta) {
+    node._$meta = meta;
+    let em = mc.entityManager;
+    let entityType = meta.entityType;
+    if (typeof (entityType) === 'string') {
+        entityType = mc.metadataStore._getStructuralType(entityType, false);
+    }
+    node.entityType = entityType;
+    let mergeStrategy = mc.mergeOptions.mergeStrategy;
+    let isSaving = mc.query == null;
+    let entityKey = entityType.getEntityKeyFromRawEntity(node, mc.rawValueFn);
+    let targetEntity = em.getEntityByKey(entityKey);
+    if (targetEntity) {
+        if (isSaving && targetEntity.entityAspect.entityState.isDeleted()) {
+            em.detachEntity(targetEntity);
+            return targetEntity;
+        }
+        let targetEntityState = targetEntity.entityAspect.entityState;
+        if (mergeStrategy === MergeStrategy.Disallowed) {
+            throw new Error("A MergeStrategy of 'Disallowed' prevents " + entityKey.toString() + " from being merged");
+        }
+        else if (mergeStrategy === MergeStrategy.SkipMerge) {
+            updateEntityNoMerge(mc, targetEntity, node);
+        }
+        else {
+            if (mergeStrategy === MergeStrategy.OverwriteChanges
+                || targetEntityState.isUnchanged()) {
+                updateEntity(mc, targetEntity, node);
+                targetEntity.entityAspect.wasLoaded = true;
+                if (meta.extraMetadata) {
+                    targetEntity.entityAspect.extraMetadata = meta.extraMetadata;
+                }
+                targetEntity.entityAspect.entityState = EntityState.Unchanged;
+                clearOriginalValues(targetEntity);
+                // propertyName not specified because multiple props EntityChangedEventArgs
+                targetEntity.entityAspect.propertyChanged.publish({ entity: targetEntity, propertyName: null });
+                let action = isSaving ? EntityAction.MergeOnSave : EntityAction.MergeOnQuery;
+                em.entityChanged.publish({ entityAction: action, entity: targetEntity });
+                // this is needed to handle an overwrite of a modified entity with an unchanged entity
+                // which might in turn cause _hasChanges to change.
+                if (!targetEntityState.isUnchanged()) {
+                    em._notifyStateChange(targetEntity, false);
+                }
+            }
+            else {
+                // process targetEntity (even if deleted) to ensure related nodes are handled
+                updateEntityNoMerge(mc, targetEntity, node);
+                if (targetEntityState === EntityState.Deleted && !mc.mergeOptions.includeDeleted) {
+                    return null;
+                }
+            }
+        }
+    }
+    else {
+        targetEntity = entityType._createInstanceCore();
+        updateEntity(mc, targetEntity, node);
+        if (meta.extraMetadata) {
+            targetEntity.entityAspect.extraMetadata = meta.extraMetadata;
+        }
+        // em._attachEntityCore(targetEntity, EntityState.Unchanged, MergeStrategy.Disallowed);
+        em._attachEntityCore(targetEntity, EntityState.Unchanged, mergeStrategy);
+        targetEntity.entityAspect.wasLoaded = true;
+        em.entityChanged.publish({ entityAction: EntityAction.AttachOnQuery, entity: targetEntity });
+    }
+    return targetEntity;
+}
+// copied from entityAspect
+function clearOriginalValues(target) {
+    let aspect = target.entityAspect || target.complexAspect;
+    aspect.originalValues = {};
+    let stype = target.entityType || target.complexType;
+    stype.complexProperties.forEach(function (cp) {
+        let cos = target.getProperty(cp.name);
+        if (cp.isScalar) {
+            clearOriginalValues(cos);
+        }
+        else {
+            cos._acceptChanges();
+            cos.forEach(clearOriginalValues);
+        }
+    });
+}
+function updateEntityNoMerge(mc, targetEntity, node) {
+    updateEntityRef(mc, targetEntity, node);
+    // we still need to merge related entities even if top level entity wasn't modified.
+    node.entityType.navigationProperties.forEach(function (np) {
+        if (np.isScalar) {
+            mergeRelatedEntityCore(mc, node, np);
+        }
+        else {
+            mergeRelatedEntitiesCore(mc, node, np);
+        }
+    });
+}
+function updateEntity(mc, targetEntity, node) {
+    updateEntityRef(mc, targetEntity, node);
+    let entityType = targetEntity.entityType;
+    entityType._updateTargetFromRaw(targetEntity, node, mc.rawValueFn);
+    entityType.navigationProperties.forEach(function (np) {
+        if (np.isScalar) {
+            mergeRelatedEntity(mc, np, targetEntity, node);
+        }
+        else {
+            mergeRelatedEntities(mc, np, targetEntity, node);
+        }
+    });
+}
+function mergeRelatedEntity(mc, navigationProperty, targetEntity, rawEntity) {
+    let relatedEntity = mergeRelatedEntityCore(mc, rawEntity, navigationProperty);
+    if (relatedEntity == null)
+        return;
+    if (typeof relatedEntity === 'function') {
+        mc.deferredFns.push(function () {
+            relatedEntity = relatedEntity();
+            updateRelatedEntity(relatedEntity, targetEntity, navigationProperty);
+        });
+    }
+    else {
+        updateRelatedEntity(relatedEntity, targetEntity, navigationProperty);
+    }
+}
+function mergeRelatedEntities(mc, navigationProperty, targetEntity, rawEntity) {
+    let relatedEntities = mergeRelatedEntitiesCore(mc, rawEntity, navigationProperty);
+    if (relatedEntities == null)
+        return;
+    let inverseProperty = navigationProperty.inverse;
+    if (!inverseProperty)
+        return;
+    let originalRelatedEntities = targetEntity.getProperty(navigationProperty.name);
+    originalRelatedEntities.wasLoaded = true;
+    relatedEntities.forEach(function (relatedEntity) {
+        if (typeof relatedEntity === 'function') {
+            mc.deferredFns.push(function () {
+                relatedEntity = relatedEntity();
+                updateRelatedEntityInCollection(mc, relatedEntity, originalRelatedEntities, targetEntity, inverseProperty);
+            });
+        }
+        else {
+            updateRelatedEntityInCollection(mc, relatedEntity, originalRelatedEntities, targetEntity, inverseProperty);
+        }
+    });
+}
+function mergeRelatedEntityCore(mc, rawEntity, navigationProperty) {
+    let relatedRawEntity = rawEntity[navigationProperty.nameOnServer];
+    if (!relatedRawEntity)
+        return null;
+    let relatedEntity = mc.visitAndMerge(relatedRawEntity, { nodeType: "navProp", navigationProperty: navigationProperty });
+    return relatedEntity;
+}
+function mergeRelatedEntitiesCore(mc, rawEntity, navigationProperty) {
+    let relatedRawEntities = rawEntity[navigationProperty.nameOnServer];
+    if (!relatedRawEntities)
+        return null;
+    // needed if what is returned is not an array and we expect one - this happens with __deferred in OData.
+    if (!Array.isArray(relatedRawEntities)) {
+        // return null;
+        relatedRawEntities = relatedRawEntities.results; // OData v3 will look like this with an expand
+        if (!relatedRawEntities) {
+            return null;
+        }
+    }
+    let relatedEntities = mc.visitAndMerge(relatedRawEntities, { nodeType: "navPropItem", navigationProperty: navigationProperty });
+    return relatedEntities;
+}
+function updateRelatedEntity(relatedEntity, targetEntity, navigationProperty) {
+    if (!relatedEntity)
+        return;
+    let propName = navigationProperty.name;
+    let currentRelatedEntity = targetEntity.getProperty(propName);
+    // check if the related entity is already hooked up
+    if (currentRelatedEntity !== relatedEntity) {
+        // if not hook up both directions.
+        targetEntity.setProperty(propName, relatedEntity);
+        let inverseProperty = navigationProperty.inverse;
+        if (!inverseProperty)
+            return;
+        if (inverseProperty.isScalar) {
+            relatedEntity.setProperty(inverseProperty.name, targetEntity);
+        }
+        else {
+            let collection = relatedEntity.getProperty(inverseProperty.name);
+            collection.push(targetEntity);
+        }
+    }
+}
+function updateRelatedEntityInCollection(mc, relatedEntity, relatedEntities, targetEntity, inverseProperty) {
+    if (!relatedEntity)
+        return;
+    // don't update relatedCollection if preserveChanges & relatedEntity has an fkChange.
+    if (relatedEntity.entityAspect.entityState === EntityState.Modified
+        && mc.mergeOptions.mergeStrategy === MergeStrategy.PreserveChanges) {
+        let origValues = relatedEntity.entityAspect.originalValues;
+        let fkWasModified = inverseProperty.relatedDataProperties.some(function (dp) {
+            return origValues[dp.name] != undefined;
+        });
+        if (fkWasModified)
+            return;
+    }
+    // check if the related entity is already hooked up
+    let thisEntity = relatedEntity.getProperty(inverseProperty.name);
+    if (thisEntity !== targetEntity) {
+        // if not - hook it up.
+        relatedEntities.push(relatedEntity);
+        relatedEntity.setProperty(inverseProperty.name, targetEntity);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mapping-context.js","sourceRoot":"","sources":["../../../src/mapping-context.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataServiceAdapter } from './interface-registry';\r\nimport { core } from './core';\r\nimport { DataType  } from './data-type';\r\nimport { DataService, JsonResultsAdapter, NodeContext, NodeMeta } from './data-service';\r\nimport { EntityState  } from './entity-state';\r\nimport { EntityAction } from './entity-action';\r\nimport { MetadataStore, EntityType, StructuralType, DataProperty, NavigationProperty } from './entity-metadata';\r\nimport { EntityManager } from './entity-manager';\r\nimport { MergeStrategy } from './query-options';\r\nimport { Entity } from './entity-aspect';\r\nimport { EntityQuery } from './entity-query';\r\n\r\n\r\n/**\r\nFor use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation. \r\n@adapter (see [[IDataServiceAdapter]])    \r\n@hidden \r\n*/\r\nexport interface MergeOptions {\r\n  mergeStrategy: MergeStrategy;\r\n  includeDeleted?: boolean;\r\n  noTracking?: boolean;\r\n}\r\n\r\n/** @hidden */\r\nexport interface MappingContextConfig {\r\n  dataService: DataService;\r\n  query?: EntityQuery | string;\r\n  entityManager: EntityManager;\r\n  mergeOptions: MergeOptions;\r\n}\r\n\r\n/**\r\nFor use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation. \r\n@adapter (see [[IDataServiceAdapter]])    \r\n@hidden \r\n*/\r\nexport class MappingContext {\r\n  /** @hidden @internal */\r\n  declare _$typeName: string; // on prototype\r\n\r\n  rawValueFn = DataProperty.getRawValueFromServer; // think about passing this in later.\r\n\r\n  declare dataService: DataService;\r\n  declare query: EntityQuery | string;\r\n  declare entityManager: EntityManager;\r\n  declare mergeOptions: MergeOptions;\r\n  declare adapter: DataServiceAdapter;  // assigned in the AbstractDataServiceAdapter.\r\n\r\n  declare refMap: Record<string, any>; // TODO\r\n  declare deferredFns: Function[]; // TODO\r\n  declare jsonResultsAdapter: JsonResultsAdapter;\r\n  declare metadataStore: MetadataStore;\r\n\r\n  constructor(config: MappingContextConfig) {\r\n\r\n    core.extend(this, config, [\r\n      \"query\", \"entityManager\", \"dataService\", \"mergeOptions\"\r\n    ]);\r\n\r\n    // calc'd props\r\n    this.refMap = {};\r\n    this.deferredFns = [];\r\n    this.jsonResultsAdapter = this.dataService.jsonResultsAdapter;\r\n    this.metadataStore = this.entityManager.metadataStore;\r\n    this.rawValueFn = DataProperty.getRawValueFromServer; // think about passing this in later.\r\n  }\r\n\r\n  getUrl() {\r\n    let query = this.query;\r\n    if (!query) {\r\n      throw new Error(\"query cannot be empty\");\r\n    }\r\n    let uriString: string;\r\n    if (typeof query === 'string') {\r\n      uriString = query;\r\n    } else if (query instanceof EntityQuery) {\r\n      uriString = this.dataService.uriBuilder!.buildUri(query, this.metadataStore);\r\n    } else {\r\n      throw new Error(\"unable to recognize query parameter as either a string or an EntityQuery\");\r\n    }\r\n    return this.dataService.qualifyUrl(uriString);\r\n  }\r\n\r\n  visitAndMerge(nodes: any[], nodeContext: any) {\r\n    let query = this.query;\r\n    let jra = this.jsonResultsAdapter;\r\n    nodeContext = nodeContext || {};\r\n    let that = this;\r\n    let result = core.map(nodes, function (node) {\r\n      if (query == null && node.entityAspect) {\r\n        // don't bother merging a result from a save that was not returned from the server.\r\n        if (node.entityAspect.entityState.isDeleted()) {\r\n          that.entityManager.detachEntity(node);\r\n        } else {\r\n          node.entityAspect.acceptChanges();\r\n        }\r\n        return node;\r\n      }\r\n\r\n      let meta = jra.visitNode(node, that, nodeContext) || {};\r\n      node = meta.node || node;\r\n      if (query && nodeContext.nodeType === \"root\" && !meta.entityType) {\r\n        meta.entityType = query instanceof EntityQuery &&  query._getToEntityType && query._getToEntityType(that.metadataStore);\r\n      }\r\n      return processMeta(that, node, meta);\r\n    }, this.mergeOptions.includeDeleted);\r\n\r\n    if (result.filter && !this.mergeOptions.includeDeleted) {\r\n      // result may have deleted entities because related nodes were processed\r\n      result = result.filter((x: any) => x && (!x.entityAspect || !x.entityAspect.entityState.isDeleted()));\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  processDeferred() {\r\n    if (this.deferredFns.length > 0) {\r\n      this.deferredFns.forEach((fn) => {\r\n        fn();\r\n      });\r\n    }\r\n  }\r\n}\r\nMappingContext.prototype._$typeName = \"MappingContext\";\r\n\r\n\r\nfunction processMeta(mc: MappingContext, node: any, meta: NodeMeta, assignFn?: (val: any) => void) {\r\n  // == is deliberate here instead of ===\r\n  if (meta.ignore || node == null) {\r\n    return null;\r\n  } else if (meta.nodeRefId) {\r\n    let refValue = resolveEntityRef(mc, meta.nodeRefId);\r\n    if (typeof refValue === \"function\" && assignFn != null) {\r\n      mc.deferredFns.push(function () {\r\n        assignFn(refValue);\r\n      });\r\n      return undefined; // deferred and will be set later;\r\n    }\r\n    return refValue;\r\n  } else if (meta.entityType) {\r\n    let entityType = meta.entityType;\r\n    if (mc.mergeOptions.noTracking) {\r\n      node = processNoMerge(mc, entityType, node);\r\n      if (entityType.noTrackingFn) {\r\n        node = entityType.noTrackingFn(node, entityType);\r\n      }\r\n      if (meta.nodeId) {\r\n        mc.refMap[meta.nodeId] = node;\r\n      }\r\n      return node;\r\n    } else {\r\n      if (entityType.isComplexType) {\r\n        // because we still need to do serverName to client name processing\r\n        return processNoMerge(mc, entityType, node);\r\n      } else {\r\n        return mergeEntity(mc, node, meta);\r\n      }\r\n    }\r\n  } else {\r\n\r\n    if ((!meta.passThru) && typeof node === 'object' && ! core.isDate(node)) {\r\n      node = processAnonType(mc, node);\r\n    }\r\n\r\n    // updating the refMap for entities is handled by updateEntityRef for entities.\r\n    if (meta.nodeId) {\r\n      mc.refMap[meta.nodeId] = node;\r\n    }\r\n    return node;\r\n  }\r\n}\r\n\r\nfunction processNoMerge(mc: MappingContext, stype: StructuralType, node: any) {\r\n  let result = {} as Record<string, any>;\r\n\r\n  stype.dataProperties.forEach(function (dp) {\r\n    if (dp.isComplexProperty) {\r\n      result[dp.name] = core.map(node[dp.nameOnServer], (v: any) => {\r\n        return processNoMerge(mc, dp.dataType as any, v);\r\n      });\r\n    } else {\r\n      result[dp.name] = DataType.parseRawValue(node[dp.nameOnServer], dp.dataType as DataType);\r\n    }\r\n  });\r\n\r\n  (stype instanceof EntityType) && stype.navigationProperties.forEach( (np) => {\r\n    let nodeContext = { nodeType: \"navProp\", navigationProperty: np };\r\n    visitNode(node[np.nameOnServer], mc, nodeContext, result, np.name);\r\n  });\r\n\r\n  return result;\r\n}\r\n\r\nfunction processAnonType(mc: MappingContext, node: any) {\r\n  // node is guaranteed to be an object by this point, i.e. not a scalar\r\n  let keyFn = mc.metadataStore.namingConvention.serverPropertyNameToClient;\r\n  let result = {};\r\n\r\n  core.objectForEach(node, function (key, value) {\r\n    let newKey = keyFn(key);\r\n    let nodeContext = { nodeType: \"anonProp\", propertyName: newKey };\r\n    visitNode(value, mc, nodeContext, result, newKey);\r\n  });\r\n  return result;\r\n}\r\n\r\nfunction visitNode(node: any, mc: MappingContext, nodeContext: NodeContext, result: Record<string, any>, key: string) {\r\n  let jra = mc.jsonResultsAdapter;\r\n  let meta = jra.visitNode(node, mc, nodeContext) || {};\r\n  // allows visitNode to change the value;\r\n  node = meta.node || node;\r\n\r\n  if (meta.ignore) return;\r\n  if (meta.passThru) return node;\r\n  if (Array.isArray(node)) {\r\n    nodeContext.nodeType = nodeContext.nodeType + \"Item\";\r\n    result[key] = node.map(function (v, ix) {\r\n      meta = jra.visitNode(v, mc, nodeContext) || {};\r\n      v = meta.node || v;\r\n      return processMeta(mc, v, meta, function (refValue) {\r\n        result[key][ix] = refValue();\r\n      });\r\n    });\r\n  } else {\r\n    result[key] = processMeta(mc, node, meta, function (refValue) {\r\n      result[key] = refValue();\r\n    });\r\n  }\r\n}\r\n\r\nfunction resolveEntityRef(mc: MappingContext, nodeRefId: string) {\r\n  let entity = mc.refMap[nodeRefId];\r\n  if (entity === undefined) {\r\n    return function () {\r\n      return mc.refMap[nodeRefId];\r\n    };\r\n  } else {\r\n    return entity;\r\n  }\r\n}\r\n\r\nfunction updateEntityRef(mc: MappingContext, targetEntity: any, node: any) {\r\n  let nodeId = node._$meta.nodeId;\r\n  if (!nodeId && node._$meta.extraMetadata) {\r\n    // odata case.  refMap isn't really used, but is returned as data.retrievedEntities, so we populated it anyway.\r\n    nodeId = node._$meta.extraMetadata.uriKey;\r\n  }\r\n  if (nodeId != null) {\r\n    mc.refMap[nodeId] = targetEntity;\r\n  }\r\n}\r\n\r\n// can return null for a deleted entity if includeDeleted == false\r\nfunction mergeEntity(mc: MappingContext, node: any, meta: NodeMeta) {\r\n  node._$meta = meta;\r\n  let em = mc.entityManager;\r\n\r\n  let entityType = meta.entityType as EntityType;\r\n  if (typeof (entityType) === 'string') {\r\n    entityType = mc.metadataStore._getStructuralType(entityType, false) as EntityType;\r\n  }\r\n  node.entityType = entityType;\r\n\r\n  let mergeStrategy = mc.mergeOptions.mergeStrategy;\r\n  let isSaving = mc.query == null;\r\n\r\n  let entityKey = entityType.getEntityKeyFromRawEntity(node, mc.rawValueFn);\r\n  let targetEntity = em.getEntityByKey(entityKey);\r\n  if (targetEntity) {\r\n    if (isSaving && targetEntity.entityAspect.entityState.isDeleted()) {\r\n      em.detachEntity(targetEntity);\r\n      return targetEntity;\r\n    }\r\n    let targetEntityState = targetEntity.entityAspect.entityState;\r\n    if (mergeStrategy === MergeStrategy.Disallowed) {\r\n      throw new Error(\"A MergeStrategy of 'Disallowed' prevents \" + entityKey.toString() + \" from being merged\");\r\n    } else if (mergeStrategy === MergeStrategy.SkipMerge) {\r\n      updateEntityNoMerge(mc, targetEntity, node);\r\n    } else {\r\n      if (mergeStrategy === MergeStrategy.OverwriteChanges\r\n        || targetEntityState.isUnchanged()) {\r\n        updateEntity(mc, targetEntity, node);\r\n        targetEntity.entityAspect.wasLoaded = true;\r\n        if (meta.extraMetadata) {\r\n          targetEntity.entityAspect.extraMetadata = meta.extraMetadata;\r\n        }\r\n        targetEntity.entityAspect.entityState = EntityState.Unchanged;\r\n        clearOriginalValues(targetEntity);\r\n        // propertyName not specified because multiple props EntityChangedEventArgs\r\n        targetEntity.entityAspect.propertyChanged.publish({ entity: targetEntity, propertyName: null });\r\n        let action = isSaving ? EntityAction.MergeOnSave : EntityAction.MergeOnQuery;\r\n        em.entityChanged.publish({ entityAction: action, entity: targetEntity });\r\n        // this is needed to handle an overwrite of a modified entity with an unchanged entity\r\n        // which might in turn cause _hasChanges to change.\r\n        if (!targetEntityState.isUnchanged()) {\r\n          em._notifyStateChange(targetEntity, false);\r\n        }\r\n      } else {\r\n        // process targetEntity (even if deleted) to ensure related nodes are handled\r\n        updateEntityNoMerge(mc, targetEntity, node);\r\n        if (targetEntityState === EntityState.Deleted && !mc.mergeOptions.includeDeleted) {\r\n          return null;\r\n        }\r\n      }\r\n    }\r\n  } else {\r\n    targetEntity = entityType._createInstanceCore() as Entity;\r\n\r\n    updateEntity(mc, targetEntity, node);\r\n\r\n    if (meta.extraMetadata) {\r\n      targetEntity.entityAspect.extraMetadata = meta.extraMetadata;\r\n    }\r\n    // em._attachEntityCore(targetEntity, EntityState.Unchanged, MergeStrategy.Disallowed);\r\n    em._attachEntityCore(targetEntity, EntityState.Unchanged, mergeStrategy);\r\n    targetEntity.entityAspect.wasLoaded = true;\r\n    em.entityChanged.publish({ entityAction: EntityAction.AttachOnQuery, entity: targetEntity });\r\n  }\r\n  return targetEntity;\r\n}\r\n\r\n// copied from entityAspect\r\nfunction clearOriginalValues(target: any) {\r\n  let aspect = target.entityAspect || target.complexAspect;\r\n  aspect.originalValues = {};\r\n  let stype = target.entityType || target.complexType;\r\n  stype.complexProperties.forEach(function (cp: any) {\r\n    let cos = target.getProperty(cp.name);\r\n    if (cp.isScalar) {\r\n      clearOriginalValues(cos);\r\n    } else {\r\n      cos._acceptChanges();\r\n      cos.forEach(clearOriginalValues);\r\n    }\r\n  });\r\n}\r\n\r\n\r\nfunction updateEntityNoMerge(mc: MappingContext, targetEntity: Entity, node: any) {\r\n  updateEntityRef(mc, targetEntity, node);\r\n  // we still need to merge related entities even if top level entity wasn't modified.\r\n  node.entityType.navigationProperties.forEach(function (np: NavigationProperty) {\r\n    if (np.isScalar) {\r\n      mergeRelatedEntityCore(mc, node, np);\r\n    } else {\r\n      mergeRelatedEntitiesCore(mc, node, np);\r\n    }\r\n  });\r\n}\r\n\r\nfunction updateEntity(mc: MappingContext, targetEntity: Entity, node: any) {\r\n  updateEntityRef(mc, targetEntity, node);\r\n  let entityType = targetEntity.entityType;\r\n  entityType._updateTargetFromRaw(targetEntity, node, mc.rawValueFn);\r\n\r\n  entityType.navigationProperties.forEach(function (np) {\r\n    if (np.isScalar) {\r\n      mergeRelatedEntity(mc, np, targetEntity, node);\r\n    } else {\r\n      mergeRelatedEntities(mc, np, targetEntity, node);\r\n    }\r\n  });\r\n}\r\n\r\nfunction mergeRelatedEntity(mc: MappingContext, navigationProperty: NavigationProperty, targetEntity: Entity, rawEntity: any) {\r\n\r\n  let relatedEntity = mergeRelatedEntityCore(mc, rawEntity, navigationProperty);\r\n  if (relatedEntity == null) return;\r\n  if (typeof relatedEntity === 'function') {\r\n    mc.deferredFns.push(function () {\r\n      relatedEntity = relatedEntity();\r\n      updateRelatedEntity(relatedEntity, targetEntity, navigationProperty);\r\n    });\r\n  } else {\r\n    updateRelatedEntity(relatedEntity, targetEntity, navigationProperty);\r\n  }\r\n}\r\n\r\nfunction mergeRelatedEntities(mc: MappingContext, navigationProperty: NavigationProperty, targetEntity: Entity, rawEntity: any) {\r\n  let relatedEntities = mergeRelatedEntitiesCore(mc, rawEntity, navigationProperty);\r\n  if (relatedEntities == null) return;\r\n\r\n  let inverseProperty = navigationProperty.inverse;\r\n  if (!inverseProperty) return;\r\n\r\n  let originalRelatedEntities = targetEntity.getProperty(navigationProperty.name);\r\n  originalRelatedEntities.wasLoaded = true;\r\n\r\n  relatedEntities.forEach(function (relatedEntity: any) {\r\n    if (typeof relatedEntity === 'function') {\r\n      mc.deferredFns.push(function () {\r\n        relatedEntity = relatedEntity();\r\n        updateRelatedEntityInCollection(mc, relatedEntity, originalRelatedEntities, targetEntity, inverseProperty as NavigationProperty);\r\n      });\r\n    } else {\r\n      updateRelatedEntityInCollection(mc, relatedEntity, originalRelatedEntities, targetEntity, inverseProperty as NavigationProperty);\r\n    }\r\n  });\r\n}\r\n\r\nfunction mergeRelatedEntityCore(mc: MappingContext, rawEntity: any, navigationProperty: NavigationProperty) {\r\n  let relatedRawEntity = rawEntity[navigationProperty.nameOnServer];\r\n  if (!relatedRawEntity) return null;\r\n\r\n  let relatedEntity = mc.visitAndMerge(relatedRawEntity, { nodeType: \"navProp\", navigationProperty: navigationProperty });\r\n  return relatedEntity;\r\n}\r\n\r\nfunction mergeRelatedEntitiesCore(mc: MappingContext, rawEntity: any, navigationProperty: NavigationProperty) {\r\n  let relatedRawEntities = rawEntity[navigationProperty.nameOnServer];\r\n  if (!relatedRawEntities) return null;\r\n\r\n  // needed if what is returned is not an array and we expect one - this happens with __deferred in OData.\r\n  if (!Array.isArray(relatedRawEntities)) {\r\n    // return null;\r\n    relatedRawEntities = relatedRawEntities.results; // OData v3 will look like this with an expand\r\n    if (!relatedRawEntities) {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  let relatedEntities = mc.visitAndMerge(relatedRawEntities, { nodeType: \"navPropItem\", navigationProperty: navigationProperty });\r\n  return relatedEntities;\r\n}\r\n\r\nfunction updateRelatedEntity(relatedEntity: Entity, targetEntity: Entity, navigationProperty: NavigationProperty) {\r\n  if (!relatedEntity) return;\r\n  let propName = navigationProperty.name;\r\n  let currentRelatedEntity = targetEntity.getProperty(propName);\r\n\r\n  // check if the related entity is already hooked up\r\n  if (currentRelatedEntity !== relatedEntity) {\r\n    // if not hook up both directions.\r\n    targetEntity.setProperty(propName, relatedEntity);\r\n    let inverseProperty = navigationProperty.inverse;\r\n    if (!inverseProperty) return;\r\n    if (inverseProperty.isScalar) {\r\n      relatedEntity.setProperty(inverseProperty.name, targetEntity);\r\n    } else {\r\n      let collection = relatedEntity.getProperty(inverseProperty.name);\r\n      collection.push(targetEntity);\r\n\r\n    }\r\n  }\r\n}\r\n\r\nfunction updateRelatedEntityInCollection(mc: MappingContext, relatedEntity: Entity | undefined,\r\n    relatedEntities: Entity[], targetEntity: Entity, inverseProperty: NavigationProperty) {\r\n  if (!relatedEntity) return;\r\n\r\n  // don't update relatedCollection if preserveChanges & relatedEntity has an fkChange.\r\n  if (relatedEntity.entityAspect.entityState === EntityState.Modified\r\n    && mc.mergeOptions.mergeStrategy === MergeStrategy.PreserveChanges) {\r\n    let origValues = relatedEntity.entityAspect.originalValues;\r\n    let fkWasModified = inverseProperty.relatedDataProperties.some(function (dp) {\r\n      return origValues[dp.name] != undefined;\r\n    });\r\n    if (fkWasModified) return;\r\n  }\r\n  // check if the related entity is already hooked up\r\n  let thisEntity = relatedEntity.getProperty(inverseProperty.name);\r\n\r\n  if (thisEntity !== targetEntity) {\r\n    // if not - hook it up.\r\n    relatedEntities.push(relatedEntity);\r\n    relatedEntity.setProperty(inverseProperty.name, targetEntity);\r\n  }\r\n}\r\n\r\n\r\n"]}

package/esm2022/src/naming-convention.mjs

@@ -0,0 +1,92 @@
+import { assertConfig } from './assert-param';
+import { core } from './core';
+import { config } from './config';
+/**
+A NamingConvention instance is used to specify the naming conventions under which a MetadataStore
+will translate property names between the server and the javascript client.
+
+The default NamingConvention does not perform any translation, it simply passes property names thru unchanged.
+@dynamic
+**/
+export class NamingConvention {
+    /** Function that takes a server property name add converts it into a client side property name.  __Read Only__ */
+    serverPropertyNameToClient;
+    /** Function that takes a client property name add converts it into a server side property name. __Read Only__ */
+    clientPropertyNameToServer;
+    /**
+    NamingConvention constructor
+    >      // A naming convention that converts the first character of every property name to uppercase on the server
+    >      // and lowercase on the client.
+    >      var namingConv = new NamingConvention({
+    >          serverPropertyNameToClient: function(serverPropertyName) {
+    >              return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
+    >          },
+    >          clientPropertyNameToServer: function(clientPropertyName) {
+    >              return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
+    >          }
+    >      });
+    >      var ms = new MetadataStore({ namingConvention: namingConv });
+    >      var em = new EntityManager( { metadataStore: ms });
+    **/
+    constructor(ncConfig) {
+        assertConfig(ncConfig || {})
+            .whereParam("name").isOptional().isString()
+            .whereParam("serverPropertyNameToClient").isFunction()
+            .whereParam("clientPropertyNameToServer").isFunction()
+            .applyAll(this);
+        if (!this.name) {
+            this.name = core.getUuid();
+        }
+        config._storeObject(this, "NamingConvention", this.name);
+    }
+    /**
+  
+  
+    /**
+    A noop naming convention - This is the default unless another is specified.
+    **/
+    static none = new NamingConvention({
+        name: "noChange",
+        serverPropertyNameToClient: (serverPropertyName) => {
+            return serverPropertyName;
+        },
+        clientPropertyNameToServer: (clientPropertyName) => {
+            return clientPropertyName;
+        }
+    });
+    /**
+    The "camelCase" naming convention - This implementation only lowercases the first character of the server property name
+    but leaves the rest of the property name intact.  If a more complicated version is needed then one should be created via the ctor.
+    **/
+    static camelCase = new NamingConvention({
+        name: "camelCase",
+        serverPropertyNameToClient: (serverPropertyName) => {
+            return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
+        },
+        clientPropertyNameToServer: (clientPropertyName) => {
+            return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
+        }
+    });
+    /**
+    The default value whenever NamingConventions are not specified.
+    **/
+    static defaultInstance = new NamingConvention(NamingConvention.none);
+    /**
+    Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.
+    The current instance is returned unchanged.
+    >      var namingConv = new NamingConvention({
+    >          serverPropertyNameToClient: function(serverPropertyName) {
+    >              return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
+    >          },
+    >          clientPropertyNameToServer: function(clientPropertyName) {
+    >              return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
+    >          }
+    >      });
+    >      namingConv.setAsDefault();
+    **/
+    setAsDefault() {
+        return core.setAsDefault(this, NamingConvention);
+    }
+}
+NamingConvention.prototype._$typeName = "NamingConvention";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"naming-convention.js","sourceRoot":"","sources":["../../../src/naming-convention.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAclC;;;;;;GAMG;AACH,MAAM,OAAO,gBAAgB;IAK3B,kHAAkH;IAClH,0BAA0B,CAAwC;IAClE,iHAAiH;IACjH,0BAA0B,CAAwC;IAElE;;;;;;;;;;;;;;OAcG;IACH,YAAY,QAAgC;QAC1C,YAAY,CAAC,QAAQ,IAAI,EAAE,CAAC;aACvB,UAAU,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE;aAC1C,UAAU,CAAC,4BAA4B,CAAC,CAAC,UAAU,EAAE;aACrD,UAAU,CAAC,4BAA4B,CAAC,CAAC,UAAU,EAAE;aACrD,QAAQ,CAAC,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;YACd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;SAC5B;QACD,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,IAAI,GAAG,IAAI,gBAAgB,CAAC;QACjC,IAAI,EAAE,UAAU;QAChB,0BAA0B,EAAE,CAAC,kBAAkB,EAAE,EAAE;YACjD,OAAO,kBAAkB,CAAC;QAC5B,CAAC;QACD,0BAA0B,EAAE,CAAC,kBAAkB,EAAE,EAAE;YACjD,OAAO,kBAAkB,CAAC;QAC5B,CAAC;KACF,CAAC,CAAC;IAEH;;;OAGG;IACH,MAAM,CAAC,SAAS,GAAG,IAAI,gBAAgB,CAAC;QACtC,IAAI,EAAE,WAAW;QACjB,0BAA0B,EAAE,CAAC,kBAAkB,EAAE,EAAE;YACjD,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACtF,CAAC;QACD,0BAA0B,EAAE,CAAC,kBAAkB,EAAE,EAAE;YACjD,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACtF,CAAC;KACF,CAAC,CAAC;IAEH;;OAEG;IACH,MAAM,CAAC,eAAe,GAAG,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAErE;;;;;;;;;;;;OAYG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;IACnD,CAAC;;AAIH,gBAAgB,CAAC,SAAS,CAAC,UAAU,GAAG,kBAAkB,CAAC","sourcesContent":["import { assertConfig } from './assert-param';\r\nimport { core } from './core';\r\nimport { config } from './config';\r\n\r\n// TODO: strongly type context object passed to naming convention converter fns.\r\n\r\n/** Configuration info to be passed to the [[NamingConvention]] constructor */\r\nexport interface NamingConventionConfig {\r\n  /** The name of this NamingConvention */\r\n  name?: string;\r\n  /** Function that takes a server property name add converts it into a client side property name.  */\r\n  serverPropertyNameToClient?: (nm: string, context?: any) => string;\r\n  /** Function that takes a client property name add converts it into a server side property name. */\r\n  clientPropertyNameToServer?: (nm: string, context?: any) => string;\r\n}\r\n\r\n/**\r\nA NamingConvention instance is used to specify the naming conventions under which a MetadataStore\r\nwill translate property names between the server and the javascript client.\r\n\r\nThe default NamingConvention does not perform any translation, it simply passes property names thru unchanged.\r\n@dynamic\r\n**/\r\nexport class NamingConvention {\r\n  /** @hidden @internal */\r\n  declare _$typeName: string;\r\n  /** The name of this NamingConvention. __Read Only__ */\r\n  declare name: string;\r\n  /** Function that takes a server property name add converts it into a client side property name.  __Read Only__ */\r\n  serverPropertyNameToClient: (nm: string, context?: any) => string;\r\n  /** Function that takes a client property name add converts it into a server side property name. __Read Only__ */\r\n  clientPropertyNameToServer: (nm: string, context?: any) => string;\r\n\r\n  /**\r\n  NamingConvention constructor\r\n  >      // A naming convention that converts the first character of every property name to uppercase on the server\r\n  >      // and lowercase on the client.\r\n  >      var namingConv = new NamingConvention({\r\n  >          serverPropertyNameToClient: function(serverPropertyName) {\r\n  >              return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);\r\n  >          },\r\n  >          clientPropertyNameToServer: function(clientPropertyName) {\r\n  >              return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);\r\n  >          }            \r\n  >      });\r\n  >      var ms = new MetadataStore({ namingConvention: namingConv });\r\n  >      var em = new EntityManager( { metadataStore: ms });\r\n  **/\r\n  constructor(ncConfig: NamingConventionConfig ) {\r\n    assertConfig(ncConfig || {})\r\n        .whereParam(\"name\").isOptional().isString()\r\n        .whereParam(\"serverPropertyNameToClient\").isFunction()\r\n        .whereParam(\"clientPropertyNameToServer\").isFunction()\r\n        .applyAll(this);\r\n    if (!this.name) {\r\n      this.name = core.getUuid();\r\n    }\r\n    config._storeObject(this, \"NamingConvention\", this.name);\r\n  }\r\n\r\n  /**\r\n\r\n\r\n  /**\r\n  A noop naming convention - This is the default unless another is specified.\r\n  **/\r\n  static none = new NamingConvention({\r\n    name: \"noChange\",\r\n    serverPropertyNameToClient: (serverPropertyName) => {\r\n      return serverPropertyName;\r\n    },\r\n    clientPropertyNameToServer: (clientPropertyName) => {\r\n      return clientPropertyName;\r\n    }\r\n  });\r\n\r\n  /**\r\n  The \"camelCase\" naming convention - This implementation only lowercases the first character of the server property name\r\n  but leaves the rest of the property name intact.  If a more complicated version is needed then one should be created via the ctor.\r\n  **/\r\n  static camelCase = new NamingConvention({\r\n    name: \"camelCase\",\r\n    serverPropertyNameToClient: (serverPropertyName) => {\r\n      return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);\r\n    },\r\n    clientPropertyNameToServer: (clientPropertyName) => {\r\n      return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);\r\n    }\r\n  });\r\n\r\n  /**\r\n  The default value whenever NamingConventions are not specified.\r\n  **/\r\n  static defaultInstance = new NamingConvention(NamingConvention.none);\r\n\r\n  /**\r\n  Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.\r\n  The current instance is returned unchanged.\r\n  >      var namingConv = new NamingConvention({\r\n  >          serverPropertyNameToClient: function(serverPropertyName) {\r\n  >              return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);\r\n  >          },\r\n  >          clientPropertyNameToServer: function(clientPropertyName) {\r\n  >              return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);\r\n  >          }            \r\n  >      });\r\n  >      namingConv.setAsDefault();\r\n  **/\r\n  setAsDefault() {\r\n    return core.setAsDefault(this, NamingConvention);\r\n  }\r\n\r\n}\r\n\r\nNamingConvention.prototype._$typeName = \"NamingConvention\";\r\n\r\n\r\n\r\n\r\n"]}