pailingual-odata
Version:
TypeScript client for OData v4 services
1,081 lines (1,040 loc) • 78.1 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["pailingual-odata"] = factory();
else
root["pailingual-odata"] = factory();
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/*!******************!*\
!*** ./index.ts ***!
\******************/
/*! exports provided: loadMetadata, metadata, serialization, CollectionSource, SingleSource, Query, Pailingual, default, ApiContextFactory */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Pailingual", function() { return Pailingual; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ApiContextFactory", function() { return ApiContextFactory; });
/* harmony import */ var _metadata__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./metadata */ 1);
/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "metadata", function() { return _metadata__WEBPACK_IMPORTED_MODULE_0__; });
/* harmony import */ var _apiContext__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./apiContext */ 8);
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ 2);
/* harmony import */ var _collectionSource__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./collectionSource */ 5);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CollectionSource", function() { return _collectionSource__WEBPACK_IMPORTED_MODULE_3__["CollectionSource"]; });
/* harmony import */ var _singleSource__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./singleSource */ 6);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "SingleSource", function() { return _singleSource__WEBPACK_IMPORTED_MODULE_4__["SingleSource"]; });
/* harmony import */ var _query__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./query */ 3);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Query", function() { return _query__WEBPACK_IMPORTED_MODULE_5__["Query"]; });
/* harmony import */ var _serialization__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./serialization */ 4);
/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "serialization", function() { return _serialization__WEBPACK_IMPORTED_MODULE_6__; });
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "loadMetadata", function() { return _metadata__WEBPACK_IMPORTED_MODULE_0__["loadMetadata"]; });
var Pailingual = /** @class */ (function () {
function Pailingual() {
}
Pailingual.use = function (plugin) {
if (plugin) {
var ext = plugin.register();
if (ext) {
ext.apiContextFn && Object(_utils__WEBPACK_IMPORTED_MODULE_2__["_extends"])(_apiContext__WEBPACK_IMPORTED_MODULE_1__["ApiContextImpl"], ext.apiContextFn);
ext.collectionSourceFn && Object(_utils__WEBPACK_IMPORTED_MODULE_2__["_extends"])(_collectionSource__WEBPACK_IMPORTED_MODULE_3__["CollectionSource"], ext.collectionSourceFn);
ext.singleSourceFn && Object(_utils__WEBPACK_IMPORTED_MODULE_2__["_extends"])(_singleSource__WEBPACK_IMPORTED_MODULE_4__["SingleSource"], ext.singleSourceFn);
ext.queryFn && Object(_utils__WEBPACK_IMPORTED_MODULE_2__["_extends"])(_query__WEBPACK_IMPORTED_MODULE_5__["Query"], ext.queryFn);
}
}
};
Pailingual.createApiContext = function (api, options) {
if (typeof api == "string") {
return _metadata__WEBPACK_IMPORTED_MODULE_0__["loadMetadata"](api)
.then(function (m) { return new _apiContext__WEBPACK_IMPORTED_MODULE_1__["ApiContextImpl"](m, options); });
}
else if (api instanceof _metadata__WEBPACK_IMPORTED_MODULE_0__["ApiMetadata"])
return new _apiContext__WEBPACK_IMPORTED_MODULE_1__["ApiContextImpl"](api, options);
throw new Error("First parameter must be api url or metadata object");
};
Pailingual.loadMetadata = function (apiRoot, options, cache) {
return _metadata__WEBPACK_IMPORTED_MODULE_0__["loadMetadata"](apiRoot, options, cache);
};
return Pailingual;
}());
/* harmony default export */ __webpack_exports__["default"] = (Pailingual);
/** @deprecated Use Palingual.createApiContext function */
var ApiContextFactory = Pailingual.createApiContext;
/***/ }),
/* 1 */
/*!*********************!*\
!*** ./metadata.ts ***!
\*********************/
/*! exports provided: EdmTypes, EdmEntityType, EdmComplexType, EdmEnumType, EdmEntityTypeReference, EdmTypeReference, OperationMetadata, Namespace, loadMetadata, ApiMetadata */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EdmTypes", function() { return EdmTypes; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EdmEntityType", function() { return EdmEntityType; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EdmComplexType", function() { return EdmComplexType; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EdmEnumType", function() { return EdmEnumType; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EdmEntityTypeReference", function() { return EdmEntityTypeReference; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EdmTypeReference", function() { return EdmTypeReference; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "OperationMetadata", function() { return OperationMetadata; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Namespace", function() { return Namespace; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "loadMetadata", function() { return loadMetadata; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ApiMetadata", function() { return ApiMetadata; });
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils */ 2);
var __extends = (undefined && undefined.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
}
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var COLLECTION_TYPE_PREFIX = "Collection(";
var EdmTypes;
(function (EdmTypes) {
EdmTypes["Int32"] = "Edm.Int32";
EdmTypes["Int16"] = "Edm.Int16";
EdmTypes["Boolean"] = "Edm.Boolean";
EdmTypes["String"] = "Edm.String";
EdmTypes["Single"] = "Edm.Single";
EdmTypes["Guid"] = "Edm.Guid";
EdmTypes["DateTimeOffset"] = "Edm.DateTimeOffset";
EdmTypes["Date"] = "Edm.Date";
EdmTypes["Double"] = "Edm.Double";
EdmTypes["TimeOfDay"] = "Edm.TimeOfDay";
EdmTypes["Decimal"] = "Edm.Decimal";
EdmTypes["Unknown"] = "Unknown";
})(EdmTypes || (EdmTypes = {}));
var EdmEntityType = /** @class */ (function () {
function EdmEntityType(name, properties, navProperties, keys, baseType, openType) {
if (navProperties === void 0) { navProperties = {}; }
var _this = this;
this.name = name;
this.properties = properties;
this.navProperties = navProperties;
this.keys = keys;
this.baseType = baseType;
this.openType = openType;
this.getFullName = function () { return getFullName(_this); };
}
return EdmEntityType;
}());
var EdmComplexType = /** @class */ (function (_super) {
__extends(EdmComplexType, _super);
function EdmComplexType() {
return _super !== null && _super.apply(this, arguments) || this;
}
return EdmComplexType;
}(EdmEntityType));
var EdmEnumType = /** @class */ (function () {
function EdmEnumType(name, members) {
var _this = this;
this.name = name;
this.members = members;
this.getFullName = function () { return getFullName(_this); };
}
return EdmEnumType;
}());
var EdmEntityTypeReference = /** @class */ (function () {
function EdmEntityTypeReference(type, nullable, collection) {
if (nullable === void 0) { nullable = true; }
if (collection === void 0) { collection = false; }
this.type = type;
this.nullable = nullable;
this.collection = collection;
}
EdmEntityTypeReference.fromTypeReference = function (typeReference) {
if (typeReference.type instanceof EdmEntityType) {
return typeReference;
}
throw new Error("Instance must be reference to EdmEntityType");
};
return EdmEntityTypeReference;
}());
var EdmTypeReference = /** @class */ (function () {
function EdmTypeReference(type, nullable, collection) {
if (nullable === void 0) { nullable = true; }
if (collection === void 0) { collection = false; }
this.type = type;
this.nullable = nullable;
this.collection = collection;
}
return EdmTypeReference;
}());
;
var OperationMetadata = /** @class */ (function () {
function OperationMetadata(name, isAction, parameters, returnType, bindingTo) {
var _this = this;
this.name = name;
this.isAction = isAction;
this.parameters = parameters;
this.returnType = returnType;
this.bindingTo = bindingTo;
this.getFullName = function () { return getFullName(_this); };
}
return OperationMetadata;
}());
function getFullName(obj) {
if (obj.namespace)
return [obj.namespace.name, obj.name].join(".");
return obj.name;
}
var Namespace = /** @class */ (function () {
function Namespace(name) {
this.name = name;
this.operations = [];
this.types = {};
}
Namespace.prototype.addTypes = function () {
var types = [];
for (var _i = 0; _i < arguments.length; _i++) {
types[_i] = arguments[_i];
}
for (var _a = 0, types_1 = types; _a < types_1.length; _a++) {
var type = types_1[_a];
type.namespace = this;
this.types[type.name] = type;
}
};
Namespace.prototype.addOperations = function () {
var operations = [];
for (var _i = 0; _i < arguments.length; _i++) {
operations[_i] = arguments[_i];
}
for (var _a = 0, operations_1 = operations; _a < operations_1.length; _a++) {
var operation = operations_1[_a];
operation.namespace = this;
this.operations.push(operation);
}
};
return Namespace;
}());
;
var __metadataCache = {};
function loadMetadata(apiRoot, options, cache) {
if (cache === void 0) { cache = true; }
if (Object(_utils__WEBPACK_IMPORTED_MODULE_0__["endsWith"])(apiRoot, "/"))
apiRoot = apiRoot.substr(0, apiRoot.length - 1);
var normalizedApiRoot = apiRoot.toLowerCase(), res = __metadataCache[normalizedApiRoot];
if (res == null || !cache) {
return ApiMetadata.loadAsync(apiRoot, options)
.then(function (md) {
if (cache)
__metadataCache[normalizedApiRoot] = md;
return md;
});
}
return Promise.resolve(res);
}
var ApiMetadata = /** @class */ (function () {
function ApiMetadata(apiRoot, containerName, namespaces, entitySets, singletons) {
if (namespaces === void 0) { namespaces = {}; }
if (entitySets === void 0) { entitySets = {}; }
if (singletons === void 0) { singletons = {}; }
this.apiRoot = apiRoot;
this.containerName = containerName;
this.namespaces = namespaces;
this.entitySets = entitySets;
this.singletons = singletons;
}
ApiMetadata.loadFromXml = function (apiRoot, metadataXml) {
var parser = new DOMParser();
var metadataDoc = parser.parseFromString(metadataXml, "text/xml");
var namespaces = ApiMetadata.parseEntityTypes(metadataDoc);
var entitySets = {};
var singletons = {};
var container = metadataDoc.querySelector("Schema>EntityContainer");
var containerName = container && getRequiredAttributeValue(container, "Name");
if (container) {
var list = container.querySelectorAll("EntitySet,Singleton");
for (var i = 0; i < list.length; i++) {
var e = list.item(i);
var isSingleton = e.tagName.toUpperCase() === "SINGLETON";
var name_1 = getRequiredAttributeValue(e, "Name");
var typeName = getRequiredAttributeValue(e, isSingleton ? "Type" : "EntityType");
var target = isSingleton ? singletons : entitySets;
target[name_1] = ApiMetadata.getEntitySetMetadata(typeName, namespaces);
}
}
var list3 = metadataDoc.querySelectorAll("Schema>Function,Schema>Action");
for (var i = 0; i < list3.length; i++) {
var e = list3.item(i);
var metadata = ApiMetadata.parseOperationMetadata(e, namespaces);
var namespaceName = getRequiredAttributeValue(e.parentElement, "Namespace");
if (!namespaces[namespaceName])
namespaces[namespaceName] = new Namespace(namespaceName);
namespaces[namespaceName].addOperations(metadata);
}
return new ApiMetadata(apiRoot, containerName, namespaces, entitySets, singletons);
};
ApiMetadata.loadAsync = function (apiRoot, options) {
return __awaiter(this, void 0, void 0, function () {
var uri, opt, fetchApi, credentials, response, _a, _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
uri = apiRoot + "/$metadata";
opt = options || {};
fetchApi = opt.fetch || fetch;
credentials = opt.credentials;
return [4 /*yield*/, fetchApi(uri, { credentials: credentials })];
case 1:
response = _c.sent();
_a = this.loadFromXml;
_b = [apiRoot];
return [4 /*yield*/, response.text()];
case 2: return [2 /*return*/, _a.apply(this, _b.concat([_c.sent()]))];
}
});
});
};
ApiMetadata.parseEntityTypes = function (metadataDoc) {
var namespaces = {};
var entityTypes = [];
var list = metadataDoc.querySelectorAll("Schema>ComplexType,Schema>EntityType,Schema>EnumType");
var _loop_1 = function () {
var e = list.item(i);
var getOrAddEdmEntityType = function (namespace, name) {
var namespaceMD = namespaces[namespace];
if (!namespaceMD)
namespaces[namespace] = namespaceMD = new Namespace(namespace);
var typeMetadata = namespaceMD.types[name];
if (!typeMetadata) {
typeMetadata = e.tagName.toLowerCase() == "complextype"
? new EdmComplexType(name, {})
: new EdmEntityType(name, {});
namespaceMD.addTypes(typeMetadata);
}
return typeMetadata;
};
var ns = getRequiredAttributeValue(e.parentElement, "Namespace");
var name_2 = getRequiredAttributeValue(e, "Name");
if (!(ns in namespaces))
namespaces[ns] = new Namespace(ns);
if (e.tagName.toLowerCase() === "enumtype") {
var enumType = new EdmEnumType(name_2, ApiMetadata.parseEnumMembers(e));
namespaces[ns].addTypes(enumType);
}
else {
var typeMetadata = getOrAddEdmEntityType(ns, name_2);
typeMetadata.openType = getAttributeBoolValue(e, "OpenType");
var baseType = getAttributeValue(e, "BaseType");
if (baseType) {
var baseTypeNS = baseType.substring(0, baseType.lastIndexOf("."));
var baseTypeName = baseType.substr(baseTypeNS.length + 1);
var bt = getOrAddEdmEntityType(baseTypeNS, baseTypeName);
typeMetadata.baseType = bt;
}
entityTypes.push({ element: e, typeMetadata: typeMetadata });
}
};
for (var i = 0; i < list.length; i++) {
_loop_1();
}
for (var _i = 0, entityTypes_1 = entityTypes; _i < entityTypes_1.length; _i++) {
var e = entityTypes_1[_i];
Object.assign(e.typeMetadata, ApiMetadata.getEntityTypeProperties(e.element, namespaces));
e.typeMetadata.keys = this.parseEntityKeys(e.element);
}
return namespaces;
};
ApiMetadata.parseEntityKeys = function (typeElement) {
var res = new Array();
var list = typeElement.querySelectorAll("Key>PropertyRef");
for (var i = 0; i < list.length; i++) {
res.push(getRequiredAttributeValue(list.item(i), "Name"));
}
return res;
};
ApiMetadata.parseEnumMembers = function (element) {
var res = {};
var list = element.querySelectorAll("Member");
for (var i = 0; i < list.length; i++) {
var e = list.item(i);
var name_3 = getRequiredAttributeValue(e, "Name");
var rawValue = getRequiredAttributeValue(e, "Value");
res[name_3] = (rawValue.match(/\d/)) ? parseInt(rawValue) : rawValue;
}
return res;
};
ApiMetadata.getEntityTypeProperties = function (typeElement, namespaces) {
var properties = {};
var navProperties = {};
var list = typeElement.querySelectorAll("Property,NavigationProperty");
for (var i = 0; i < list.length; i++) {
var e = list.item(i);
var name_4 = getRequiredAttributeValue(e, "Name");
var metadata = ApiMetadata.parseType(e, namespaces);
if (e.tagName.toLowerCase() == "property")
properties[name_4] = metadata;
else
navProperties[name_4] = EdmEntityTypeReference.fromTypeReference(metadata);
}
return { properties: properties, navProperties: navProperties };
};
ApiMetadata.prototype.getEntitySetMetadata = function (typeName) {
return ApiMetadata.getEntitySetMetadata(typeName, this.namespaces);
};
ApiMetadata.getEntitySetMetadata = function (typeName, namespaces) {
var res = ApiMetadata.getEdmTypeMetadata(typeName, namespaces);
if (res instanceof EdmEntityType)
return res;
throw new Error("EntitySet item type must be entity");
};
ApiMetadata.prototype.getEdmTypeMetadata = function (typeName) {
return ApiMetadata.getEdmTypeMetadata(typeName, this.namespaces);
};
ApiMetadata.getEdmTypeMetadata = function (typeName, namespaces) {
if (Object(_utils__WEBPACK_IMPORTED_MODULE_0__["startsWith"])(typeName, COLLECTION_TYPE_PREFIX))
typeName = typeName.substring(COLLECTION_TYPE_PREFIX.length, typeName.length - 1);
var namespace = typeName.substring(0, typeName.lastIndexOf("."));
var typeNameNoNs = typeName.substr(namespace.length + 1);
if (namespace == "Edm") {
var t = EdmTypes[typeNameNoNs];
if (!t)
throw new Error("Not registred Edm type: " + typeNameNoNs);
return t;
}
var nsMeta = namespaces[namespace];
if (!nsMeta)
throw new Error("Namespace '" + namespace + "' not found");
var typeElement = nsMeta.types[typeNameNoNs];
return typeElement;
};
ApiMetadata.parseOperationMetadata = function (operationElement, namespaces) {
var isAction = operationElement.tagName.toLowerCase() === "action";
var name = getRequiredAttributeValue(operationElement, "Name");
var returnTypeElement = operationElement.querySelector("ReturnType");
var returnType = returnTypeElement
? ApiMetadata.parseType(returnTypeElement, namespaces)
: undefined;
var parameters = new Array();
var bindingTo;
var list = operationElement.querySelectorAll("Parameter");
for (var i = 0; i < list.length; i++) {
var e = list.item(i);
var type = ApiMetadata.parseType(e, namespaces);
var name_5 = getRequiredAttributeValue(e, "Name");
if (getAttributeBoolValue(operationElement, "IsBound") && !bindingTo)
bindingTo = EdmEntityTypeReference.fromTypeReference(type);
else
parameters.push({ name: name_5, type: type });
}
return new OperationMetadata(name, isAction, parameters, returnType, bindingTo);
};
ApiMetadata.parseType = function (element, namespaces) {
var typeName = getRequiredAttributeValue(element, "Type");
var collection = Object(_utils__WEBPACK_IMPORTED_MODULE_0__["startsWith"])(typeName, COLLECTION_TYPE_PREFIX);
if (collection)
typeName = typeName.substring(COLLECTION_TYPE_PREFIX.length, typeName.length - 1);
var typeMetadata = ApiMetadata.getEdmTypeMetadata(typeName, namespaces);
var res = new EdmTypeReference(typeMetadata, true, collection);
res.nullable = getAttributeBoolValue(element, "Nullable") != false;
return res;
};
return ApiMetadata;
}());
function getRequiredAttributeValue(element, attrName) {
return getAttributeValue(element, attrName) || (function () {
throw new Error("Metadata: Attribute '" + attrName + "' in element '" + element.tagName + "' not found ");
})();
}
function getAttributeBoolValue(element, attrName) {
var r = getAttributeValue(element, attrName);
if (r != undefined)
return r.toLowerCase() == "true";
}
function getAttributeValue(element, attrName) {
var attr = element.attributes.getNamedItem(attrName);
if (attr)
return attr.value;
}
/***/ }),
/* 2 */
/*!******************!*\
!*** ./utils.ts ***!
\******************/
/*! exports provided: expandExpressionBuild, buildPathExpression, buildQueryParamsExpression, generateOperations, startsWith, endsWith, _extends */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "expandExpressionBuild", function() { return expandExpressionBuild; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "buildPathExpression", function() { return buildPathExpression; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "buildQueryParamsExpression", function() { return buildQueryParamsExpression; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "generateOperations", function() { return generateOperations; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "startsWith", function() { return startsWith; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "endsWith", function() { return endsWith; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_extends", function() { return _extends; });
/* harmony import */ var _query__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./query */ 3);
/* harmony import */ var _collectionSource__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./collectionSource */ 5);
/* harmony import */ var _singleSource__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./singleSource */ 6);
/* harmony import */ var _executable__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./executable */ 7);
function expandExpressionBuild(propertyName, expression, apiMetadata, entityType, options) {
var navPropMD = entityType.navProperties[propertyName];
if (navPropMD == null)
throw new Error("Expand support navigation properties only");
var propType = navPropMD.type;
var q = _query__WEBPACK_IMPORTED_MODULE_0__["Query"].create(apiMetadata, propType, options);
var sourceFactory = function () { return navPropMD.collection
? new _collectionSource__WEBPACK_IMPORTED_MODULE_1__["CollectionSource"](propType, apiMetadata, q)
: new _singleSource__WEBPACK_IMPORTED_MODULE_2__["SingleSource"](propType, apiMetadata, q); };
var params = buildQueryParamsExpression(expression, sourceFactory, options, ";");
if (params)
return propertyName + "(" + params + ")";
return propertyName;
}
function buildPathExpression(func, metadata, apiMetadata) {
var entity = new _singleSource__WEBPACK_IMPORTED_MODULE_2__["SingleSource"](metadata, apiMetadata, _query__WEBPACK_IMPORTED_MODULE_0__["Query"].create(null, metadata, undefined));
entity = func(entity);
var path = entity.query.url(false);
if (startsWith(path, "/"))
return path.substr(1);
return path;
}
function buildQueryParamsExpression(func, sourceFactory, options, separator) {
if (separator === void 0) { separator = ","; }
var entity = sourceFactory();
entity = func(entity);
return entity.query.buildParams(options, separator);
}
function generateOperations(obj, queryAccessor, apiMetadata, entityType, isCollection) {
if (isCollection === void 0) { isCollection = false; }
for (var ns in apiMetadata.namespaces) {
var _loop_1 = function (metadata) {
if ((metadata.bindingTo == undefined && entityType == undefined) //unbounded
|| (metadata.bindingTo
&& (metadata.bindingTo.collection || false) == isCollection
&& metadata.bindingTo.type == entityType)) {
Object.defineProperty(obj, metadata.name, {
get: function () {
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var query = queryAccessor().operation(metadata, args);
if (metadata.returnType && metadata.returnType.collection)
return new _collectionSource__WEBPACK_IMPORTED_MODULE_1__["CollectionSource"](metadata.returnType.type, apiMetadata, query);
return new _executable__WEBPACK_IMPORTED_MODULE_3__["Executable"](query);
};
}
});
}
};
for (var _i = 0, _a = apiMetadata.namespaces[ns].operations; _i < _a.length; _i++) {
var metadata = _a[_i];
_loop_1(metadata);
}
}
}
function startsWith(str, search, position) {
if (position === void 0) { position = 0; }
return str.indexOf(search, position) == position;
}
function endsWith(subjectString, search, position) {
if (position === undefined || position > subjectString.length) {
position = subjectString.length;
}
position -= search.length;
var lastIndex = subjectString.indexOf(search, position);
return lastIndex !== -1 && lastIndex === position;
}
function _extends(ctor, funcs) {
if (funcs) {
var _loop_2 = function () {
var base = ctor.prototype[name];
var func = funcs[name];
ctor.prototype[name] = function () {
return func.apply(this, [base && base.bind(this)].concat(Array.from(arguments)));
};
};
for (var name in funcs) {
_loop_2();
}
}
}
/***/ }),
/* 3 */
/*!******************!*\
!*** ./query.ts ***!
\******************/
/*! exports provided: Query */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Query", function() { return Query; });
/* harmony import */ var _metadata__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./metadata */ 1);
/* harmony import */ var _serialization__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./serialization */ 4);
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ 2);
var __extends = (undefined && undefined.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
}
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var Query = /** @class */ (function () {
function Query(_apiMetadata, _entityMetadata, _options) {
this._apiMetadata = _apiMetadata;
this._entityMetadata = _entityMetadata;
this._options = _options;
this._segments = [];
this.params = {};
this._method = "get";
}
Query.create = function (apiMetadata, entityMetadata, options) {
return new Query(apiMetadata, entityMetadata, options)._freeze();
};
Query.prototype._clone = function (beforeFreeze) {
var res = new Query(this._apiMetadata, this._entityMetadata, this._options);
res._segments = this._segments.slice();
var cloneArray = function (a) { return a ? a.slice() : null; };
for (var _i = 0, _a = Object.getOwnPropertyNames(this.params); _i < _a.length; _i++) {
var name_1 = _a[_i];
var val = this.params[name_1];
if (val != undefined) {
res.params[name_1] = Array.isArray(val)
? cloneArray(val)
: val;
}
}
res._method = this._method;
res._payload = this._payload;
if (beforeFreeze)
beforeFreeze(res);
return res._freeze();
};
Query.prototype._freeze = function () {
var _this = this;
//freeze segments
this._segments = Object.freeze(this._segments);
//freeze params
Object.getOwnPropertyNames(this.params).forEach(function (n) {
var v = _this.params[n];
if (v !== null && typeof v === "object")
Object.freeze(v);
});
this.params = Object.freeze(this.params);
this._payload = Object.freeze(this._payload);
//freze query
return Object.freeze(this);
};
Query.prototype._action = function (metadata, args) {
return this._clone(function (q) {
q._segments.push(new ActionSegment(metadata));
q._method = "post";
q._entityMetadata = metadata.returnType && metadata.returnType.type;
if (args && args.length > 0) {
var payload = {};
var edmProps = {};
if (metadata.parameters) {
for (var i = 0; i < args.length; i++) {
var param = metadata.parameters[i];
payload[param.name] = args[i];
edmProps[param.name] = param.type;
}
}
q._entityMetadata = new _metadata__WEBPACK_IMPORTED_MODULE_0__["EdmEntityType"]("", edmProps);
q._payload = payload;
}
});
};
Query.prototype._func = function (metadata, args) {
return this._clone(function (q) {
q._entityMetadata = metadata.returnType && metadata.returnType.type;
q._segments.push(new FuncSegment(metadata, args));
});
};
Query.prototype.byKey = function (keyExpr) {
return this._clone(function (q) {
var pos = q._segments.length;
if (q._segments[pos - 1] instanceof CastSegment)
pos--;
q._segments.splice(pos, 0, new KeySegment(keyExpr));
});
};
Query.prototype.cast = function (fullTypeName) {
return this._clone(function (q) { return q._segments.push(new CastSegment(fullTypeName)); });
};
Query.prototype.navigate = function (property, entityMetadata) {
return this._clone(function (q) {
q._entityMetadata = entityMetadata;
q._segments.push(new NavigationSegment(property));
});
};
Query.prototype.operation = function (metadata, args) {
return metadata.isAction
? this._action(metadata, args)
: this._func(metadata, args);
};
Query.prototype.count = function (o) {
if (o === void 0) { o = { inline: false }; }
return this._clone(function (q) {
if (o.inline)
q.params.count = true;
else
q._segments.push(new CountSegment());
});
};
Query.prototype.delete = function () {
return this._clone(function (q) {
q._method = "delete";
});
};
Query.prototype.expand = function (expand, expr) {
return this._clone(function (q) {
var expandParam = q.params.expand == null
? q.params.expand = []
: q.params.expand;
expandParam.push({ expand: expand, expr: expr });
});
};
Query.prototype.filter = function (expr) {
return this._clone(function (q) {
var filters = (q.params.filter == null)
? q.params.filter = new Array()
: q.params.filter;
filters.push(expr);
});
};
Query.prototype.insert = function (payload) {
return this._clone(function (q) {
q._payload = payload;
q._method = "post";
});
};
Query.prototype.orderBy = function (expressions) {
return this._clone(function (q) {
var _a;
if (expressions) {
if (!q.params.orderBy)
q.params.orderBy = [];
(_a = q.params.orderBy).push.apply(_a, expressions);
}
});
};
Query.prototype.search = function (expr) {
return this._clone(function (q) {
if (!q.params.search)
q.params.search = [];
q.params.search.push(expr);
});
};
Query.prototype.select = function (fields) {
return this._clone(function (q) { return q.params.select = fields; });
};
Query.prototype.skip = function (num) {
return this._clone(function (q) { return q.params.skip = num; });
};
Query.prototype.top = function (num) {
return this._clone(function (q) { return q.params.top = num; });
};
Query.prototype.update = function (payload, put) {
return this._clone(function (q) {
q._payload = payload;
q._method = put ? "put" : "patch";
});
};
Query.prototype.url = function (queryParams, options) {
if (queryParams === void 0) { queryParams = true; }
var apiRoot = (this._apiMetadata && this._apiMetadata.apiRoot) || "";
var params = queryParams ? this.params : undefined;
var opt = Object.assign({}, this._options, options);
var url = apiRoot + this._segments
.map(function (s) { return s.toUrlFragment(opt); })
.join("");
if (params) {
var urlParams = this.buildParams(opt, '&');
if (urlParams)
return url + "?" + urlParams;
}
return url;
};
Query.prototype.buildParams = function (options, separator) {
var _this = this;
if (separator === void 0) { separator = "&"; }
return Object.getOwnPropertyNames(this.params)
.map(function (n) { return _this.params[n] && _this.processParameter(n, _this.params[n], options); })
.filter(function (v) { return v; })
.join(separator);
};
Query.prototype.processParameter = function (name, value, options) {
var _this = this;
switch (name) {
case "select":
return "$select=" + value.join(",");
case "expand":
return "$expand=" + value.map(function (e) { return _this.expandToString(e, options); }).join(",");
case "filter":
return "$filter=" + value.join(" and ");
case "orderBy":
return "$orderby=" + value.join(",");
case "skip":
return "$skip=" + value;
case "top":
return "$top=" + value;
case "count":
return value === true ? "$count=true" : undefined;
case "search":
return "$search=" + value.join(" AND ");
}
};
Query.prototype.expandToString = function (e, options) {
if (e.expr)
return Object(_utils__WEBPACK_IMPORTED_MODULE_2__["expandExpressionBuild"])(e.expand, e.expr, this._apiMetadata, this._entityMetadata, options);
return e.expand;
};
Query.prototype.exec = function (options) {
var opt = Object.assign({}, this._options, options);
var url = this.url(true, opt);
return this._fetchData(url, opt);
};
Query.prototype._fetchData = function (url, options) {
var _this = this;
var fetchApi = (options && options.fetch) || fetch;
var inputFormatter = Object(_serialization__WEBPACK_IMPORTED_MODULE_1__["getFormatter"])(options.format || "application/json");
var body = this._payload ? inputFormatter.serialize(this._payload, this._entityMetadata, options) : null;
return fetchApi(url, {
method: this._method,
body: body,
headers: { "Content-Type": inputFormatter.contentType, "X-Requested-With": "XMLHttpRequest" },
credentials: options.credentials
})
.then(function (response) { return new Promise(function (resolve, reject) {
if (response.body)
response.text().then(function (body) { return resolve({ response: response, body: body }); }, reject);
else
resolve({ response: response });
}); })
.then(function (data) {
var bodyStr = data.body;
var response = data.response;
var contentType = response.headers.get("Content-Type");
if (response.ok) {
if (bodyStr && bodyStr.length > 0) {
if (!contentType) {
if (Object(_utils__WEBPACK_IMPORTED_MODULE_2__["startsWith"])(bodyStr, "{"))
contentType = "application/json";
}
else
contentType = contentType.split(";")[0].trim();
var outputFormatter = Object(_serialization__WEBPACK_IMPORTED_MODULE_1__["getFormatter"])(contentType);
return outputFormatter.deserialize(bodyStr, _this._apiMetadata, options);
}
else
return null;
}
else {
try {
var odError = bodyStr && JSON.parse(bodyStr);
}
catch (_a) { }
var error = (odError && odError.error) || response.statusText;
throw { status: response.status, error: error };
}
});
};
return Query;
}());
var Segment = /** @class */ (function () {
function Segment() {
}
return Segment;
}());
var NavigationSegment = /** @class */ (function (_super) {
__extends(NavigationSegment, _super);
function NavigationSegment(property) {
var _this = _super.call(this) || this;
_this.property = property;
return _this;
}
NavigationSegment.prototype.toUrlFragment = function () {
return "/" + this.property;
};
return NavigationSegment;
}(Segment));
var KeySegment = /** @class */ (function (_super) {
__extends(KeySegment, _super);
function KeySegment(key) {
var _this = _super.call(this) || this;
_this.key = key;
return _this;
}
KeySegment.prototype.toUrlFragment = function () {
return "(" + this.key + ")";
};
return KeySegment;
}(Segment));
var ActionSegment = /** @class */ (function (_super) {
__extends(ActionSegment, _super);
function ActionSegment(_metadata) {
var _this = _super.call(this) || this;
_this._metadata = _metadata;
return _this;
}
ActionSegment.prototype.toUrlFragment = function (options) {
var actionName = this._metadata.bindingTo
&& options.enableUnqualifiedNameCall != true
? this._metadata.getFullName()
: this._metadata.name;
return "/" + actionName;
};
return ActionSegment;
}(Segment));
var FuncSegment = /** @class */ (function (_super) {
__extends(FuncSegment, _super);
function FuncSegment(__metadata, __args) {
var _this = _super.call(this) || this;
_this.__metadata = __metadata;
_this.__args = __args;
return _this;
}
FuncSegment.prototype.toUrlFragment = function (options) {
var _this = this;
var actionName = this.__metadata.bindingTo
&& options.enableUnqualifiedNameCall != true
? this.__metadata.getFullName()
: this.__metadata.name;
var serializedArgs = this.__args.map(function (a, i) {
if (_this.__metadata.parameters) {
var paramMetadata = _this.__metadata.parameters[i];
if (paramMetadata != null) {
var v = Object(_serialization__WEBPACK_IMPORTED_MODULE_1__["serializeValue"])(a, paramMetadata.type.type, true);
return [paramMetadata.name, v].join("=");
}
}
throw new Error("Parameter '" + i + "', for funct