breeze-client 2.1.7 → 2.2.0

package/esm2022/src/csdl-metadata-parser.mjs

@@ -0,0 +1,385 @@
+import { core } from './core';
+import { MetadataStore, EntityType, ComplexType, DataProperty, NavigationProperty, AutoGeneratedKeyType } from './entity-metadata';
+import { DataType } from './data-type';
+import { Validator } from './validate';
+const RX_COLLECTION = /Collection\((.*)\)/;
+function parse(metadataStore, schemas, altMetadata) {
+    metadataStore._entityTypeResourceMap = {};
+    schemas = core.toArray(schemas);
+    schemas.forEach(function (schema) {
+        if (schema.cSpaceOSpaceMapping) {
+            // Web api only - not avail in OData.
+            // TODO throw informative error if already parsed and converted to map on a previous pass
+            let mappings = JSON.parse(schema.cSpaceOSpaceMapping);
+            let newMap = {};
+            mappings.forEach(function (mapping) {
+                newMap[mapping[0]] = mapping[1];
+            });
+            schema.cSpaceOSpaceMapping = newMap;
+        }
+        if (schema.entityContainer) {
+            core.toArray(schema.entityContainer).forEach(function (container) {
+                core.toArray(container.entitySet).forEach(function (entitySet) {
+                    let entityTypeName = parseTypeNameWithSchema(entitySet.entityType, schema).typeName;
+                    metadataStore.setEntityTypeForResourceName(entitySet.name, entityTypeName);
+                    metadataStore._entityTypeResourceMap[entityTypeName] = entitySet.name;
+                });
+            });
+        }
+        // process complextypes before entity types.
+        if (schema.complexType) {
+            core.toArray(schema.complexType).forEach(function (ct) {
+                parseCsdlComplexType(ct, schema, metadataStore);
+            });
+        }
+        if (schema.entityType) {
+            core.toArray(schema.entityType).forEach(function (et) {
+                parseCsdlEntityType(et, schema, schemas, metadataStore);
+            });
+        }
+    });
+    let badNavProps = metadataStore.getIncompleteNavigationProperties();
+    if (badNavProps.length > 0) {
+        let msg = badNavProps.map(function (npa) {
+            if (Array.isArray(npa)) {
+                return npa.map(function (np) {
+                    return np.parentType.name + ":" + np.name;
+                }).join(', ');
+            }
+            return npa.parentType.name + ":" + npa.name;
+        }).join(', ');
+        throw new Error("Incomplete navigation properties: " + msg);
+    }
+    if (altMetadata) {
+        metadataStore.importMetadata(altMetadata, true);
+    }
+    return metadataStore;
+}
+function parseCsdlEntityType(csdlEntityType, schema, schemas, metadataStore) {
+    let shortName = csdlEntityType.name;
+    let ns = getNamespaceFor(shortName, schema);
+    let entityType = new EntityType({
+        shortName: shortName,
+        namespace: ns,
+        isAbstract: csdlEntityType.abstract && csdlEntityType.abstract === 'true'
+    });
+    if (csdlEntityType.baseType) {
+        let baseTypeName = parseTypeNameWithSchema(csdlEntityType.baseType, schema).typeName;
+        entityType.baseTypeName = baseTypeName;
+        let baseEntityType = metadataStore._getStructuralType(baseTypeName, true);
+        if (baseEntityType) {
+            completeParseCsdlEntityType(entityType, csdlEntityType, schema, schemas, metadataStore);
+        }
+        else {
+            let deferrals = metadataStore._deferredTypes[baseTypeName];
+            if (!deferrals) {
+                deferrals = [];
+                metadataStore._deferredTypes[baseTypeName] = deferrals;
+            }
+            deferrals.push({ entityType: entityType, csdlEntityType: csdlEntityType });
+        }
+    }
+    else {
+        completeParseCsdlEntityType(entityType, csdlEntityType, schema, schemas, metadataStore);
+    }
+    // entityType may or may not have been added to the metadataStore at this point.
+    return entityType;
+}
+function completeParseCsdlEntityType(entityType, csdlEntityType, schema, schemas, metadataStore) {
+    let keyNamesOnServer = csdlEntityType.key ? core.toArray(csdlEntityType.key.propertyRef).map(core.pluck("name")) : [];
+    core.toArray(csdlEntityType.property).forEach(function (prop) {
+        parseCsdlDataProperty(entityType, prop, schema, keyNamesOnServer);
+    });
+    core.toArray(csdlEntityType.navigationProperty).forEach(function (prop) {
+        parseCsdlNavProperty(entityType, prop, schema, schemas);
+    });
+    metadataStore.addEntityType(entityType);
+    entityType.defaultResourceName = metadataStore._entityTypeResourceMap[entityType.name];
+    let deferredTypes = metadataStore._deferredTypes;
+    let deferrals = deferredTypes[entityType.name];
+    if (deferrals) {
+        deferrals.forEach(function (d) {
+            completeParseCsdlEntityType(d.entityType, d.csdlEntityType, schema, schemas, metadataStore);
+        });
+        delete deferredTypes[entityType.name];
+    }
+}
+function parseCsdlComplexType(csdlComplexType, schema, metadataStore) {
+    let shortName = csdlComplexType.name;
+    let ns = getNamespaceFor(shortName, schema);
+    let complexType = new ComplexType({
+        shortName: shortName,
+        namespace: ns
+    });
+    core.toArray(csdlComplexType.property).forEach(function (prop) {
+        parseCsdlDataProperty(complexType, prop, schema);
+    });
+    metadataStore.addEntityType(complexType);
+    return complexType;
+}
+function parseCsdlDataProperty(parentType, csdlProperty, schema, keyNamesOnServer) {
+    let dp;
+    let typeParts = csdlProperty.type.split(".");
+    // Both tests on typeParts are necessary because of differing metadata conventions for OData and Edmx feeds.
+    if (typeParts[0].endsWith("Edm") && typeParts.length === 2) {
+        dp = parseCsdlSimpleProperty(parentType, csdlProperty, keyNamesOnServer);
+    }
+    else {
+        if (isEnumType(csdlProperty, schema)) {
+            dp = parseCsdlSimpleProperty(parentType, csdlProperty, keyNamesOnServer);
+            if (dp) {
+                dp.enumType = csdlProperty.type;
+            }
+        }
+        else {
+            dp = parseCsdlComplexProperty(parentType, csdlProperty, schema);
+        }
+    }
+    if (dp) {
+        parentType._addPropertyCore(dp);
+        addValidators(dp);
+    }
+    return dp;
+}
+function parseCsdlSimpleProperty(parentType, csdlProperty, keyNamesOnServer) {
+    let isCollectionType = isCollection(csdlProperty.type);
+    let propertyType = getCollectionType(csdlProperty.type) || csdlProperty.type;
+    let dataType = DataType.fromEdmDataType(propertyType);
+    if (dataType == null) {
+        parentType.warnings.push("Unable to recognize DataType for property: " + csdlProperty.name + " DateType: " + csdlProperty.type);
+        return undefined;
+    }
+    let isNullable = csdlProperty.nullable === 'true' || csdlProperty.nullable == null;
+    // let fixedLength = csdlProperty.fixedLength ? csdlProperty.fixedLength === true : undefined;
+    let isPartOfKey = keyNamesOnServer != null && keyNamesOnServer.indexOf(csdlProperty.name) >= 0;
+    if (isPartOfKey && parentType instanceof EntityType && parentType.autoGeneratedKeyType === AutoGeneratedKeyType.None) {
+        if (isIdentityProperty(csdlProperty)) {
+            parentType.autoGeneratedKeyType = AutoGeneratedKeyType.Identity;
+        }
+    }
+    // TODO: nit - don't set maxLength if null;
+    let maxLength = csdlProperty.maxLength;
+    maxLength = (maxLength == null || maxLength === "Max") ? null : parseInt(maxLength, 10);
+    // can't set the name until we go thru namingConventions and these need the dp.
+    let dp = new DataProperty({
+        nameOnServer: csdlProperty.name,
+        dataType: dataType,
+        isNullable: isNullable,
+        isPartOfKey: isPartOfKey,
+        isScalar: !isCollectionType,
+        maxLength: maxLength,
+        defaultValue: csdlProperty.defaultValue,
+        // fixedLength: fixedLength,
+        concurrencyMode: csdlProperty.concurrencyMode
+    });
+    if (dataType === DataType.Undefined) {
+        dp.rawTypeName = csdlProperty.type;
+    }
+    return dp;
+}
+function parseCsdlComplexProperty(parentType, csdlProperty, schema) {
+    // Complex properties are never nullable ( per EF specs)
+    // let isNullable = csdlProperty.nullable === 'true' || csdlProperty.nullable == null;
+    // let complexTypeName = csdlProperty.type.split("Edm.")[1];
+    let isCollectionType = isCollection(csdlProperty.type);
+    let propertyType = getCollectionType(csdlProperty.type) || csdlProperty.type;
+    let complexTypeName = parseTypeNameWithSchema(propertyType, schema).typeName;
+    // can't set the name until we go thru namingConventions and these need the dp.
+    let dp = new DataProperty({
+        nameOnServer: csdlProperty.name,
+        complexTypeName: complexTypeName,
+        isNullable: false,
+        isScalar: !isCollectionType
+    });
+    return dp;
+}
+function parseCsdlNavProperty(entityType, csdlProperty, schema, schemas) {
+    let association = getAssociation(csdlProperty, schema, schemas);
+    if (!association) {
+        throw new Error("Unable to resolve Foreign Key Association: " + csdlProperty.relationship);
+    }
+    let toEnd = core.arrayFirst(association.end, (assocEnd) => {
+        return assocEnd.role === csdlProperty.toRole;
+    });
+    let isScalar = toEnd.multiplicity !== "*";
+    let dataType = parseTypeNameWithSchema(toEnd.type, schema).typeName;
+    let constraint = association.referentialConstraint;
+    if (!constraint) {
+        // TODO: Revisit this later - right now we just ignore many-many and assocs with missing constraints.
+        // Think about adding this back later.
+        if (association.end[0].multiplicity === "*" && association.end[1].multiplicity === "*") {
+            // ignore many to many relations for now
+            return;
+        }
+        else {
+            // For now assume it will be set later directly on the client.
+            // other alternative is to throw an error:
+            // throw new Error("Foreign Key Associations must be turned on for this model");
+        }
+    }
+    let cfg = {
+        nameOnServer: csdlProperty.name,
+        entityTypeName: dataType,
+        isScalar: isScalar,
+        associationName: association.name,
+    };
+    if (constraint) {
+        let principal = constraint.principal;
+        let dependent = constraint.dependent;
+        let propRefs = core.toArray(dependent.propertyRef);
+        let fkNames = propRefs.map(core.pluck("name"));
+        if (csdlProperty.fromRole === principal.role) {
+            cfg.invForeignKeyNamesOnServer = fkNames;
+        }
+        else {
+            // will be used later by np._update
+            cfg.foreignKeyNamesOnServer = fkNames;
+        }
+    }
+    let np = new NavigationProperty(cfg);
+    entityType._addPropertyCore(np);
+    return np;
+}
+function isCollection(propertyType) {
+    return RX_COLLECTION.test(propertyType);
+}
+function isEnumType(csdlProperty, schema) {
+    if (schema.enumType)
+        return isEdmxEnumType(csdlProperty, schema);
+    else if (schema.extensions)
+        return isODataEnumType(csdlProperty, schema);
+    else
+        return false;
+}
+function isEdmxEnumType(csdlProperty, schema) {
+    let enumTypes = core.toArray(schema.enumType);
+    let propertyType = getCollectionType(csdlProperty.type) || csdlProperty.type;
+    let typeParts = propertyType.split(".");
+    let baseTypeName = typeParts[typeParts.length - 1];
+    return enumTypes.some(function (enumType) {
+        return enumType.name === baseTypeName;
+    });
+}
+function isODataEnumType(csdlProperty, schema) {
+    let enumTypes = schema.extensions.filter((ext) => {
+        return ext.name === "EnumType";
+    });
+    let propertyType = getCollectionType(csdlProperty.type) || csdlProperty.type;
+    let typeParts = propertyType.split(".");
+    let baseTypeName = typeParts[typeParts.length - 1];
+    return enumTypes.some((enumType) => {
+        return enumType.attributes.some((attr) => {
+            return attr.name === "Name" && attr.value === baseTypeName;
+        });
+    });
+}
+function addValidators(dataProperty) {
+    let typeValidator;
+    if (!dataProperty.isNullable) {
+        dataProperty.validators.push(Validator.required());
+    }
+    if (dataProperty.isComplexProperty)
+        return;
+    if (dataProperty.dataType === DataType.String) {
+        if (dataProperty.maxLength) {
+            let validatorArgs = { maxLength: dataProperty.maxLength };
+            typeValidator = Validator.maxLength(validatorArgs);
+        }
+        else {
+            typeValidator = Validator.string();
+        }
+    }
+    else {
+        let validatorCtor = dataProperty.dataType.validatorCtor;
+        if (!validatorCtor)
+            return;
+        typeValidator = validatorCtor();
+    }
+    dataProperty.validators.push(typeValidator);
+}
+function isIdentityProperty(csdlProperty) {
+    // see if web api feed
+    let propName = core.arrayFirst(Object.keys(csdlProperty), (pn) => {
+        return pn.indexOf("StoreGeneratedPattern") >= 0;
+    });
+    if (propName) {
+        return (csdlProperty[propName] === "Identity");
+    }
+    else {
+        // see if Odata feed
+        let extensions = csdlProperty.extensions;
+        if (!extensions) {
+            return false;
+        }
+        let identityExtn = core.arrayFirst(extensions, (extension) => {
+            return extension.name === "StoreGeneratedPattern" && extension.value === "Identity";
+        });
+        return !!identityExtn;
+    }
+}
+// Fast version
+// np: schema.entityType[].navigationProperty.relationship -> schema.association
+//   match( shortName(np.relationship) == schema.association[].name
+//      --> association__
+// Correct version
+// np: schema.entityType[].navigationProperty.relationship -> schema.association
+//   match( np.relationship == schema.entityContainer[0].associationSet[].association )
+//      -> associationSet.name
+//   match ( associationSet.name == schema.association[].name )
+//      -> association
+function getAssociation(csdlNavProperty, containingSchema, schemas) {
+    let assocFullName = parseTypeNameWithSchema(csdlNavProperty.relationship, containingSchema);
+    let assocNamespace = assocFullName.namespace;
+    let assocSchema = core.arrayFirst(schemas, (schema) => {
+        return schema.namespace === assocNamespace;
+    });
+    if (!assocSchema)
+        return null;
+    let assocName = assocFullName.shortTypeName;
+    let assocs = assocSchema.association;
+    if (!assocs)
+        return null;
+    if (!Array.isArray(assocs)) {
+        assocs = [assocs];
+    }
+    let association = core.arrayFirst(assocs, (assoc) => {
+        return assoc.name === assocName;
+    });
+    return association;
+}
+// schema is only needed for navProperty type name
+function parseTypeNameWithSchema(entityTypeName, schema) {
+    let result = MetadataStore.parseTypeName(entityTypeName);
+    if (schema && schema.cSpaceOSpaceMapping) {
+        let ns = getNamespaceFor(result.shortTypeName, schema);
+        if (ns) {
+            result = MetadataStore.makeTypeHash(result.shortTypeName, ns);
+        }
+    }
+    return result;
+}
+function getCollectionType(propertyType) {
+    const match = propertyType.match(RX_COLLECTION);
+    return match ? match[1] : null;
+}
+function getNamespaceFor(shortName, schema) {
+    let ns;
+    let mapping = schema.cSpaceOSpaceMapping;
+    if (mapping) {
+        let fullName = mapping[schema.namespace + "." + shortName];
+        ns = fullName && fullName.substr(0, fullName.length - (shortName.length + 1));
+        if (ns)
+            return ns;
+    }
+    // if schema does not also have an entityType node then
+    // this is an WebApi2 OData schema which is usually equal to 'Default'; which is useless.
+    if (schema.entityType || schema.namespace !== 'Default') {
+        return schema.namespace;
+    }
+    return null;
+}
+/** @hidden @internal */
+export const CsdlMetadataParser = {
+    parse: parse
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"csdl-metadata-parser.js","sourceRoot":"","sources":["../../../src/csdl-metadata-parser.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from './core';\r\nimport { MetadataStore, EntityType, ComplexType, DataProperty, NavigationProperty, AutoGeneratedKeyType } from './entity-metadata';\r\nimport { DataType  } from './data-type';\r\nimport { Validator } from './validate';\r\n\r\ninterface IAssociation {\r\n  name: string;\r\n  end: IEnd[];\r\n  referentialConstraint: any;\r\n}\r\n\r\ninterface IEnd {\r\n  multiplicity: string;\r\n  type: string;\r\n  role: string;\r\n}\r\n\r\nconst RX_COLLECTION =  /Collection\\((.*)\\)/;\r\n\r\nfunction parse(metadataStore: MetadataStore, schemas: any, altMetadata: any) {\r\n\r\n  metadataStore._entityTypeResourceMap = {};\r\n  schemas = core.toArray(schemas);\r\n  schemas.forEach(function (schema: any) {\r\n    if (schema.cSpaceOSpaceMapping) {\r\n      // Web api only - not avail in OData.\r\n      // TODO throw informative error if already parsed and converted to map on a previous pass\r\n      let mappings = JSON.parse(schema.cSpaceOSpaceMapping);\r\n      let newMap = {};\r\n      mappings.forEach(function (mapping: any) {\r\n        newMap[mapping[0]] = mapping[1];\r\n      });\r\n      schema.cSpaceOSpaceMapping = newMap;\r\n    }\r\n\r\n    if (schema.entityContainer) {\r\n      core.toArray(schema.entityContainer).forEach(function (container) {\r\n        core.toArray(container.entitySet).forEach(function (entitySet) {\r\n          let entityTypeName = parseTypeNameWithSchema(entitySet.entityType, schema).typeName;\r\n          metadataStore.setEntityTypeForResourceName(entitySet.name, entityTypeName);\r\n          metadataStore._entityTypeResourceMap[entityTypeName] = entitySet.name;\r\n        });\r\n      });\r\n    }\r\n\r\n    // process complextypes before entity types.\r\n    if (schema.complexType) {\r\n      core.toArray(schema.complexType).forEach(function (ct) {\r\n        parseCsdlComplexType(ct, schema, metadataStore);\r\n      });\r\n    }\r\n    if (schema.entityType) {\r\n      core.toArray(schema.entityType).forEach(function (et) {\r\n        parseCsdlEntityType(et, schema, schemas, metadataStore);\r\n\r\n      });\r\n    }\r\n\r\n  });\r\n  let badNavProps = metadataStore.getIncompleteNavigationProperties();\r\n  if (badNavProps.length > 0) {\r\n    let msg = badNavProps.map(function (npa) {\r\n      if (Array.isArray(npa)) {\r\n        return npa.map(function (np) {\r\n          return np.parentType.name + \":\" + np.name;\r\n        }).join(', ');\r\n      }\r\n      return npa.parentType.name + \":\" + npa.name;\r\n    }).join(', ');\r\n    throw new Error(\"Incomplete navigation properties: \" + msg);\r\n  }\r\n  if (altMetadata) {\r\n    metadataStore.importMetadata(altMetadata, true);\r\n  }\r\n  return metadataStore;\r\n}\r\n\r\nfunction parseCsdlEntityType(csdlEntityType: any, schema: any, schemas: any, metadataStore: MetadataStore) {\r\n  let shortName = csdlEntityType.name;\r\n  let ns = getNamespaceFor(shortName, schema);\r\n  let entityType = new EntityType({\r\n    shortName: shortName,\r\n    namespace: ns,\r\n    isAbstract: csdlEntityType.abstract && csdlEntityType.abstract === 'true'\r\n  });\r\n  if (csdlEntityType.baseType) {\r\n    let baseTypeName = parseTypeNameWithSchema(csdlEntityType.baseType, schema).typeName;\r\n    entityType.baseTypeName = baseTypeName;\r\n    let baseEntityType = metadataStore._getStructuralType(baseTypeName, true);\r\n    if (baseEntityType) {\r\n      completeParseCsdlEntityType(entityType, csdlEntityType, schema, schemas, metadataStore);\r\n    } else {\r\n      let deferrals = metadataStore._deferredTypes[baseTypeName];\r\n      if (!deferrals) {\r\n        deferrals = [];\r\n        metadataStore._deferredTypes[baseTypeName] = deferrals;\r\n      }\r\n      deferrals.push({ entityType: entityType, csdlEntityType: csdlEntityType });\r\n    }\r\n  } else {\r\n    completeParseCsdlEntityType(entityType, csdlEntityType, schema, schemas, metadataStore);\r\n  }\r\n  // entityType may or may not have been added to the metadataStore at this point.\r\n  return entityType;\r\n\r\n}\r\n\r\nfunction completeParseCsdlEntityType(entityType: EntityType, csdlEntityType: any, schema: any, schemas: any, metadataStore: MetadataStore) {\r\n  let keyNamesOnServer = csdlEntityType.key ? core.toArray(csdlEntityType.key.propertyRef).map(core.pluck(\"name\")) : [];\r\n\r\n  core.toArray(csdlEntityType.property).forEach(function (prop) {\r\n    parseCsdlDataProperty(entityType, prop, schema, keyNamesOnServer);\r\n  });\r\n\r\n  core.toArray(csdlEntityType.navigationProperty).forEach(function (prop) {\r\n    parseCsdlNavProperty(entityType, prop, schema, schemas);\r\n  });\r\n\r\n  metadataStore.addEntityType(entityType);\r\n  entityType.defaultResourceName = metadataStore._entityTypeResourceMap[entityType.name];\r\n\r\n  let deferredTypes = metadataStore._deferredTypes;\r\n  let deferrals = deferredTypes[entityType.name];\r\n  if (deferrals) {\r\n    deferrals.forEach(function (d: any) {\r\n      completeParseCsdlEntityType(d.entityType, d.csdlEntityType, schema, schemas, metadataStore);\r\n    });\r\n    delete deferredTypes[entityType.name];\r\n  }\r\n\r\n}\r\n\r\nfunction parseCsdlComplexType(csdlComplexType: any, schema: any, metadataStore: MetadataStore) {\r\n  let shortName = csdlComplexType.name;\r\n  let ns = getNamespaceFor(shortName, schema);\r\n  let complexType = new ComplexType({\r\n    shortName: shortName,\r\n    namespace: ns\r\n  });\r\n\r\n  core.toArray(csdlComplexType.property).forEach(function (prop) {\r\n    parseCsdlDataProperty(complexType, prop, schema);\r\n  });\r\n\r\n  metadataStore.addEntityType(complexType);\r\n  return complexType;\r\n}\r\n\r\nfunction parseCsdlDataProperty(parentType: EntityType | ComplexType, csdlProperty: any, schema: any, keyNamesOnServer?: string[]) {\r\n  let dp: DataProperty | undefined;\r\n  let typeParts = csdlProperty.type.split(\".\");\r\n  // Both tests on typeParts are necessary because of differing metadata conventions for OData and Edmx feeds.\r\n  if (typeParts[0].endsWith(\"Edm\") && typeParts.length === 2) {\r\n    dp = parseCsdlSimpleProperty(parentType, csdlProperty, keyNamesOnServer);\r\n  } else {\r\n    if (isEnumType(csdlProperty, schema)) {\r\n      dp = parseCsdlSimpleProperty(parentType, csdlProperty, keyNamesOnServer);\r\n      if (dp) {\r\n        dp.enumType = csdlProperty.type;\r\n      }\r\n    } else {\r\n      dp = parseCsdlComplexProperty(parentType, csdlProperty, schema);\r\n    }\r\n  }\r\n  if (dp) {\r\n    parentType._addPropertyCore(dp);\r\n    addValidators(dp);\r\n  }\r\n  return dp;\r\n}\r\n\r\nfunction parseCsdlSimpleProperty(parentType: EntityType | ComplexType, csdlProperty: any, keyNamesOnServer?: string[]) {\r\n  let isCollectionType = isCollection(csdlProperty.type);\r\n  let propertyType = getCollectionType(csdlProperty.type) || csdlProperty.type;\r\n  let dataType = DataType.fromEdmDataType(propertyType);\r\n  if (dataType == null) {\r\n    parentType.warnings.push(\"Unable to recognize DataType for property: \" + csdlProperty.name + \" DateType: \" + csdlProperty.type);\r\n    return undefined;\r\n  }\r\n  let isNullable = csdlProperty.nullable === 'true' || csdlProperty.nullable == null;\r\n  // let fixedLength = csdlProperty.fixedLength ? csdlProperty.fixedLength === true : undefined;\r\n  let isPartOfKey = keyNamesOnServer != null && keyNamesOnServer.indexOf(csdlProperty.name) >= 0;\r\n  if (isPartOfKey && parentType instanceof EntityType && parentType.autoGeneratedKeyType === AutoGeneratedKeyType.None) {\r\n    if (isIdentityProperty(csdlProperty)) {\r\n      parentType.autoGeneratedKeyType = AutoGeneratedKeyType.Identity;\r\n    }\r\n  }\r\n  // TODO: nit - don't set maxLength if null;\r\n  let maxLength = csdlProperty.maxLength;\r\n  maxLength = (maxLength == null || maxLength === \"Max\") ? null : parseInt(maxLength, 10);\r\n  // can't set the name until we go thru namingConventions and these need the dp.\r\n\r\n  let dp = new DataProperty({\r\n    nameOnServer: csdlProperty.name,\r\n    dataType: dataType,\r\n    isNullable: isNullable,\r\n    isPartOfKey: isPartOfKey,\r\n    isScalar: !isCollectionType,\r\n    maxLength: maxLength,\r\n    defaultValue: csdlProperty.defaultValue,\r\n    // fixedLength: fixedLength,\r\n    concurrencyMode: csdlProperty.concurrencyMode\r\n  });\r\n\r\n  if (dataType === DataType.Undefined) {\r\n    dp.rawTypeName = csdlProperty.type;\r\n  }\r\n  return dp;\r\n}\r\n\r\nfunction parseCsdlComplexProperty(parentType: EntityType | ComplexType, csdlProperty: any, schema: any) {\r\n\r\n  // Complex properties are never nullable ( per EF specs)\r\n  // let isNullable = csdlProperty.nullable === 'true' || csdlProperty.nullable == null;\r\n  // let complexTypeName = csdlProperty.type.split(\"Edm.\")[1];\r\n  let isCollectionType = isCollection(csdlProperty.type);\r\n  let propertyType = getCollectionType(csdlProperty.type) || csdlProperty.type;\r\n  let complexTypeName = parseTypeNameWithSchema(propertyType, schema).typeName;\r\n  // can't set the name until we go thru namingConventions and these need the dp.\r\n  let dp = new DataProperty({\r\n    nameOnServer: csdlProperty.name,\r\n    complexTypeName: complexTypeName,\r\n    isNullable: false,\r\n    isScalar: !isCollectionType\r\n  });\r\n\r\n  return dp;\r\n}\r\n\r\nfunction parseCsdlNavProperty(entityType: EntityType, csdlProperty: any, schema: any, schemas: any[]) {\r\n  let association = getAssociation(csdlProperty, schema, schemas);\r\n  if (!association) {\r\n    throw new Error(\"Unable to resolve Foreign Key Association: \" + csdlProperty.relationship);\r\n  }\r\n  let toEnd = core.arrayFirst(association.end, (assocEnd) => {\r\n    return assocEnd.role === csdlProperty.toRole;\r\n  });\r\n\r\n  let isScalar = toEnd!.multiplicity !== \"*\";\r\n  let dataType = parseTypeNameWithSchema(toEnd!.type, schema).typeName;\r\n\r\n  let constraint = association.referentialConstraint;\r\n  if (!constraint) {\r\n    // TODO: Revisit this later - right now we just ignore many-many and assocs with missing constraints.\r\n\r\n    // Think about adding this back later.\r\n    if (association.end[0].multiplicity === \"*\" && association.end[1].multiplicity === \"*\") {\r\n      // ignore many to many relations for now\r\n      return;\r\n    } else {\r\n      // For now assume it will be set later directly on the client.\r\n      // other alternative is to throw an error:\r\n      // throw new Error(\"Foreign Key Associations must be turned on for this model\");\r\n    }\r\n  }\r\n\r\n\r\n\r\n  let cfg = {\r\n    nameOnServer: csdlProperty.name,\r\n    entityTypeName: dataType,\r\n    isScalar: isScalar,\r\n    associationName: association.name,\r\n  };\r\n\r\n  if (constraint) {\r\n    let principal = constraint.principal;\r\n    let dependent = constraint.dependent;\r\n\r\n    let propRefs = core.toArray(dependent.propertyRef);\r\n    let fkNames = propRefs.map(core.pluck(\"name\"));\r\n    if (csdlProperty.fromRole === principal.role) {\r\n      (cfg as any).invForeignKeyNamesOnServer = fkNames;\r\n    } else {\r\n      // will be used later by np._update\r\n      (cfg as any).foreignKeyNamesOnServer = fkNames;\r\n    }\r\n  }\r\n\r\n  let np = new NavigationProperty(cfg);\r\n  entityType._addPropertyCore(np);\r\n  return np;\r\n}\r\n\r\nfunction isCollection(propertyType: string): boolean {\r\n  return RX_COLLECTION.test(propertyType);\r\n}\r\n\r\nfunction isEnumType(csdlProperty: any, schema: any) {\r\n  if (schema.enumType) return isEdmxEnumType(csdlProperty, schema);\r\n  else if (schema.extensions) return isODataEnumType(csdlProperty, schema);\r\n  else return false;\r\n}\r\n\r\nfunction isEdmxEnumType(csdlProperty: any, schema: any) {\r\n  let enumTypes = core.toArray(schema.enumType);\r\n  let propertyType = getCollectionType(csdlProperty.type) || csdlProperty.type;\r\n  let typeParts = propertyType.split(\".\");\r\n  let baseTypeName = typeParts[typeParts.length - 1];\r\n  return enumTypes.some(function (enumType) {\r\n    return enumType.name === baseTypeName;\r\n  });\r\n}\r\n\r\nfunction isODataEnumType(csdlProperty: any, schema: any) {\r\n  let enumTypes = schema.extensions.filter((ext: any) => {\r\n    return ext.name === \"EnumType\";\r\n  });\r\n  let propertyType = getCollectionType(csdlProperty.type) || csdlProperty.type;\r\n  let typeParts = propertyType.split(\".\");\r\n  let baseTypeName = typeParts[typeParts.length - 1];\r\n  return enumTypes.some((enumType: any) => {\r\n    return enumType.attributes.some((attr: any) => {\r\n      return attr.name === \"Name\" && attr.value === baseTypeName;\r\n    });\r\n  });\r\n}\r\n\r\nfunction addValidators(dataProperty: DataProperty) {\r\n  let typeValidator: Validator;\r\n  if (!dataProperty.isNullable) {\r\n    dataProperty.validators.push(Validator.required());\r\n  }\r\n\r\n  if (dataProperty.isComplexProperty) return;\r\n\r\n  if (dataProperty.dataType === DataType.String) {\r\n    if (dataProperty.maxLength) {\r\n      let validatorArgs = { maxLength: dataProperty.maxLength };\r\n      typeValidator = Validator.maxLength(validatorArgs);\r\n    } else {\r\n      typeValidator = Validator.string();\r\n    }\r\n  } else {\r\n      let validatorCtor = (dataProperty.dataType as any).validatorCtor;\r\n      if (!validatorCtor) return;\r\n      typeValidator = validatorCtor();\r\n  }\r\n\r\n  dataProperty.validators.push(typeValidator);\r\n\r\n}\r\n\r\nfunction isIdentityProperty(csdlProperty: any) {\r\n  // see if web api feed\r\n  let propName = core.arrayFirst(Object.keys(csdlProperty), (pn) => {\r\n    return pn.indexOf(\"StoreGeneratedPattern\") >= 0;\r\n  });\r\n  if (propName) {\r\n    return (csdlProperty[propName] === \"Identity\");\r\n  } else {\r\n    // see if Odata feed\r\n    let extensions = csdlProperty.extensions;\r\n    if (!extensions) {\r\n      return false;\r\n    }\r\n    let identityExtn = core.arrayFirst(extensions, (extension) => {\r\n      return extension.name === \"StoreGeneratedPattern\" && extension.value === \"Identity\";\r\n    });\r\n    return !!identityExtn;\r\n  }\r\n}\r\n\r\n// Fast version\r\n// np: schema.entityType[].navigationProperty.relationship -> schema.association\r\n//   match( shortName(np.relationship) == schema.association[].name\r\n//      --> association__\r\n\r\n// Correct version\r\n// np: schema.entityType[].navigationProperty.relationship -> schema.association\r\n//   match( np.relationship == schema.entityContainer[0].associationSet[].association )\r\n//      -> associationSet.name\r\n//   match ( associationSet.name == schema.association[].name )\r\n//      -> association\r\n\r\nfunction getAssociation(csdlNavProperty: any, containingSchema: any, schemas: any[]) {\r\n  let assocFullName = parseTypeNameWithSchema(csdlNavProperty.relationship, containingSchema);\r\n  let assocNamespace = assocFullName.namespace;\r\n  let assocSchema = core.arrayFirst(schemas, (schema) => {\r\n    return schema.namespace === assocNamespace;\r\n  });\r\n  if (!assocSchema) return null;\r\n\r\n  let assocName = assocFullName.shortTypeName;\r\n  let assocs = assocSchema.association;\r\n  if (!assocs) return null;\r\n  if (!Array.isArray(assocs)) {\r\n    assocs = [assocs];\r\n  }\r\n  let association = core.arrayFirst(assocs, (assoc) => {\r\n    return assoc.name === assocName;\r\n  });\r\n  return association as IAssociation;\r\n}\r\n\r\n// schema is only needed for navProperty type name\r\nfunction parseTypeNameWithSchema(entityTypeName: string, schema: any) {\r\n  let result = MetadataStore.parseTypeName(entityTypeName);\r\n  if (schema && schema.cSpaceOSpaceMapping) {\r\n    let ns = getNamespaceFor(result!.shortTypeName, schema);\r\n    if (ns) {\r\n      result = MetadataStore.makeTypeHash(result!.shortTypeName, ns);\r\n    }\r\n  }\r\n  return result;\r\n}\r\n\r\nfunction getCollectionType(propertyType: string): string {\r\n  const match = propertyType.match(RX_COLLECTION);\r\n  return match ? match[1] : null;\r\n}\r\n\r\nfunction getNamespaceFor(shortName: string, schema: any) {\r\n  let ns: string;\r\n  let mapping = schema.cSpaceOSpaceMapping;\r\n  if (mapping) {\r\n    let fullName = mapping[schema.namespace + \".\" + shortName];\r\n    ns = fullName && fullName.substr(0, fullName.length - (shortName.length + 1));\r\n    if (ns) return ns;\r\n  }\r\n  // if schema does not also have an entityType node then\r\n  // this is an WebApi2 OData schema which is usually equal to 'Default'; which is useless.\r\n  if (schema.entityType || schema.namespace !== 'Default') {\r\n    return schema.namespace;\r\n  }\r\n  return null;\r\n}\r\n\r\n/** @hidden @internal */\r\nexport const CsdlMetadataParser = {\r\n  parse: parse\r\n};\r\n"]}