diff --git a/breeze/breeze-1.2-tests.ts b/breeze/breeze-1.2-tests.ts
new file mode 100644
index 000000000..cb1beb082
--- /dev/null
+++ b/breeze/breeze-1.2-tests.ts
@@ -0,0 +1,797 @@
+///
+
+import core = breezeCore;
+
+function test_dataType() {
+ var typ = breeze.DataType.DateTime;
+ var nm = typ.getName();
+ var isNumber = typ.isNumeric;
+ var dv = typ.defaultValue;
+ var symbs = breeze.DataType.getSymbols();
+ var x = typ.parentEnum === breeze.DataType;
+ var isFalse = breeze.DataType.contains(breeze.DataType.Double);
+ var dt = breeze.DataType.fromName("Decimal");
+
+}
+
+function test_dataProperty() {
+ var lastNameProp = new breeze.DataProperty({
+ name: "lastName",
+ dataType: breeze.DataType.String,
+ isNullable: true,
+ maxLength: 20
+ });
+ var personEntityType: breeze.EntityType;
+ personEntityType.addProperty(lastNameProp);
+}
+
+function test_dataService() {
+ var ds = new breeze.DataService({
+ serviceName: "api/NorthwindIBModel",
+ hasServerMetadata: true
+ });
+ var em = new breeze.EntityManager({
+ dataService: ds
+ });
+
+}
+
+function test_entityAspect() {
+ var order: breeze.Entity;
+ order.entityAspect.acceptChanges();
+ var entityKey = order.entityAspect.getKey();
+ var valErrors = order.entityAspect.getValidationErrors();
+ var orderDateErrors = order.entityAspect.getValidationErrors("OrderDate");
+ var orderDateProperty = order.entityType.getProperty("OrderDate");
+ var orderDateErrors = order.entityAspect.getValidationErrors(orderDateProperty);
+ order.entityAspect.loadNavigationProperty("Orders").then(function (data) {
+ var orders = data.results;
+ }).fail(function (exception) { });
+ order.entityAspect.rejectChanges();
+ order.entityAspect.setDeleted();
+ order.entityAspect.setModified();
+ order.entityAspect.setUnchanged();
+ var isOk = order.entityAspect.validateEntity();
+ if (!isOk) {
+ var errors = order.entityAspect.getValidationErrors();
+ }
+ var isOk = order.entityAspect.validateProperty("Order");
+ var orderDateProperty = order.entityType.getProperty("OrderDate");
+ //var isOk = order.entityAspect.validateProperty(OrderDateProperty);
+ order.entityAspect.propertyChanged.subscribe(function (propertyChangedArgs) {
+ var entity = propertyChangedArgs.entity;
+ var propertyNameChanged = propertyChangedArgs.propertyName;
+ var oldValue = propertyChangedArgs.oldValue;
+ var newValue = propertyChangedArgs.newValue;
+ });
+ order.entityAspect.validationErrorsChanged.subscribe(function (validationChangeArgs) {
+ var entity = validationChangeArgs.entity;
+ var errorsAdded = validationChangeArgs.added;
+ var errorsCleared = validationChangeArgs.removed;
+ });
+
+}
+
+function test_entityKey() {
+ var em1: breeze.EntityManager;
+ var employee1: breeze.Entity;
+ var empType = em1.metadataStore.getEntityType("Employee");
+ var entityKey = new breeze.EntityKey( empType, 1);
+ var empKey = employee1.entityAspect.getKey();
+ var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory");
+ var empTerrKey = new breeze.EntityKey( empTerrType, [1, 77]);
+ var empType = em1.metadataStore.getEntityType("Employee");
+ var empKey1 = new breeze.EntityKey( empType, 1);
+ var empKey2 = employee1.entityAspect.getKey();
+ if (empKey1.equals(empKey2)) { }
+ if (breeze.EntityKey.equals(empKey1, empKey2)) { }
+}
+
+function test_metadataStore() {
+ var ms = new breeze.MetadataStore();
+ var entityManager = new breeze.EntityManager({
+ serviceName: "api/NorthwindIBModel",
+ metadataStore: ms
+ });
+ var em1: breeze.EntityManager;
+ em1.setProperties({ metadataStore: ms });
+ var metadataAsString = ms.exportMetadata();
+ window.localStorage.setItem("metadata", metadataAsString);
+ var metadataFromStorage = window.localStorage.getItem("metadata");
+ var newMetadataStore = new breeze.MetadataStore();
+ newMetadataStore.importMetadata(metadataFromStorage);
+ var ms = new breeze.MetadataStore();
+ ms.fetchMetadata("api/NorthwindIBModel")
+ .then(function (rawMetadata) { })
+ .fail(function (exception) { });
+ var odType = em1.metadataStore.getEntityType("OrderDetail");
+ var badType = em1.metadataStore.getEntityType("Foo", false);
+ var allTypes = em1.metadataStore.getEntityTypes();
+ if (!em1.metadataStore.hasMetadataFor("api/NorthwindIBModel")) { }
+ var metadataAsString = ms.exportMetadata();
+ window.localStorage.setItem("metadata", metadataAsString);
+ var metadataFromStorage = window.localStorage.getItem("metadata");
+ var newMetadataStore = breeze.MetadataStore.importMetadata(metadataFromStorage);
+ var metadataAsString = ms.exportMetadata();
+ window.localStorage.setItem("metadata", metadataAsString);
+ var metadataFromStorage = window.localStorage.getItem("metadata");
+ var newMetadataStore = new breeze.MetadataStore();
+ newMetadataStore.importMetadata(metadataFromStorage);
+ if (em1.metadataStore.isEmpty()) { }
+ var Customer = function () {
+ this.miscData = "asdf";
+ }
+ em1.metadataStore.registerEntityTypeCtor("Customer", Customer);
+}
+
+function test_entityManager() {
+ var entityManager = new breeze.EntityManager("api/NorthwindIBModel");
+ var em1 = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
+ var metadataStore = new breeze.MetadataStore();
+ var entityManager = new breeze.EntityManager({
+ serviceName: "api/NorthwindIBModel",
+ metadataStore: metadataStore
+ });
+
+ return new breeze.QueryOptions({
+ mergeStrategy: null,
+ fetchStrategy: this.fetchStrategy
+ });
+ var queryOptions = new breeze.QueryOptions({
+ mergeStrategy: breeze.MergeStrategy.OverwriteChanges,
+ fetchStrategy: breeze.FetchStrategy.FromServer
+ });
+ var validationOptions = new breeze.ValidationOptions({
+ validateOnAttach: true,
+ validateOnSave: true,
+ validateOnQuery: false
+ });
+ var entityManager = new breeze.EntityManager({
+ serviceName: "api/NorthwindIBModel",
+ queryOptions: queryOptions,
+ validationOptions: validationOptions
+ });
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var cust1 = custType.createEntity();
+ em1.addEntity(cust1);
+
+ var cust2 = em1.createEntity("Customer", { companyName: "foo" });
+ var cust3 = em1.createEntity("foo", { xxx: 3 }, breeze.EntityState.Added);
+
+ em1.attachEntity(cust1, breeze.EntityState.Added);
+ em1.clear();
+ var em2 = em1.createEmptyCopy();
+ em1.detachEntity(cust1);
+ var serviceName: string;
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders");
+ em.executeQuery(query)
+ .then(function (data) {
+ var orders = data.results;
+ }).fail(function (err) {
+ });
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders");
+ em.executeQuery(query,
+ function (data) {
+ var orders = data.results;
+ },
+ function (err) {
+ });
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders").using(em);
+ query.execute()
+ .then(function (data) {
+ var orders = data.results;
+ }).fail(function (err) {
+ });
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders");
+ var orders = em.executeQueryLocally(query);
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders").using(breeze.FetchStrategy.FromLocalCache);
+ em.executeQuery(query)
+ .then(function (data) {
+ var orders = data.results;
+ }).fail(function (err) {
+ });
+ var bundle = em1.exportEntities();
+ window.localStorage.setItem("myEntityManager", bundle);
+ var bundleFromStorage = window.localStorage.getItem("myEntityManager");
+ var em2 = new breeze.EntityManager({
+ serviceName: em1.serviceName,
+ metadataStore: em1.metadataStore
+ });
+ em2.importEntities(bundleFromStorage);
+ var entitiesToExport: breeze.Entity[];
+ var bundle = em1.exportEntities(entitiesToExport);
+ em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges });
+ var em1 = new breeze.EntityManager("api/NorthwindIBModel");
+ em1.fetchMetadata()
+ .then(function () {
+ var metadataStore = em1.metadataStore;
+ })
+ .fail(function (exception) {
+ });
+ var employeeType = em1.metadataStore.getEntityType("Employee");
+ var employeeKey = new breeze.EntityKey( employeeType, 1);
+ var employee = em1.fetchEntityByKey(employeeKey);
+ var emp2 = em1.fetchEntityByKey("Employee", 6);
+ var emp3 = em1.fetchEntityByKey("Entityee", [6]);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var custumer = custType.createEntity();
+ var customerId = em.generateTempKeyValue(custumer);
+ em1.saveChanges()
+ .then(function (data) {
+ var sameCust1 = data.results[0];
+ });
+ var changedEntities = em1.getChanges();
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var changedCustomers = em1.getChanges(custType);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var changedCustomersAndOrders = em1.getChanges([custType, orderType]);
+ var entities = em1.getEntities();
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var customers = em1.getEntities(custType);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var customersAndOrders = em1.getChanges([custType, orderType]);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var addedCustomersAndOrders = em1.getEntities([custType, orderType], breeze.EntityState.Added);
+ if (em1.hasChanges()) { }
+ var custType = em1.metadataStore.getEntityType("Customer");
+ if (em1.hasChanges(custType)) { }
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var orderType = em1.metadataStore.getEntityType("Order");
+ if (em1.hasChanges([custType, orderType])) { };
+
+ var bundle = em1.exportEntities();
+ window.localStorage.setItem("myEntityManager", bundle);
+ var bundleFromStorage = window.localStorage.getItem("myEntityManager");
+ var em2 = breeze.EntityManager.importEntities(bundleFromStorage);
+ var bundle = em1.exportEntities();
+ var em2 = new breeze.EntityManager({
+ serviceName: em1.serviceName,
+ metadataStore: em1.metadataStore
+ });
+ em2.importEntities(bundle);
+ var bundle = em1.exportEntities();
+ em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges });
+ em.saveChanges().then(function (saveResult) {
+ var savedEntities = saveResult.entities;
+ var keyMappings = saveResult.keyMappings;
+ }).fail(function (e) {
+ });
+ var saveOptions = new breeze.SaveOptions({ allowConcurrentSaves: true });
+ var entitiesToSave: breeze.Entity[];
+ em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult) {
+ var savedEntities = saveResult.entities;
+ var keyMappings = saveResult.keyMappings;
+ }).fail(function (e) {
+ });
+ em.saveChanges(entitiesToSave, null,
+ function (saveResult) {
+ var savedEntities = saveResult.entities;
+ var keyMappings = saveResult.keyMappings;
+ }, function (e) { }
+ );
+ em1.setProperties({
+ serviceName: "api/foo",
+ });
+ var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
+ em.entityChanged.subscribe(function (changeArgs) {
+ var action = changeArgs.entityAction;
+ var entity = changeArgs.entity;
+ });
+ var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
+ em.hasChangesChanged.subscribe(function (args) {
+ var hasChanges = args.hasChanges;
+ var entityManager = args.entityManager;
+ });
+}
+
+function test_entityQuery() {
+ var query = new breeze.EntityQuery("Customers");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .orderBy("Region");
+ var serviceName: string;
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders").using(em);
+ query.execute()
+ .then(function (data) { })
+ .fail(function (err) { });
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders").using(em);
+ query.execute(
+ function (data) {
+ var orders = data.results;
+ },
+ function (err) { });
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders");
+ em.executeQuery(query)
+ .then(function (data) {
+ var orders = data.results;
+ }).fail(function (err) {
+ });
+ var query = new breeze.EntityQuery("Orders").using(em);
+ var orders = query.executeLocally();
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .expand("Orders");
+ var query = new breeze.EntityQuery("Orders")
+ .expand("Customer, Employee");
+ var query = new breeze.EntityQuery("Orders")
+ .expand("Customer, OrderDetails, OrderDetails.Product");
+ var query = breeze.EntityQuery.from("Customers");
+ var query = new breeze.EntityQuery("Customers");
+ var query = new breeze.EntityQuery().from("Customers");
+ var customer: breeze.Entity;
+ var customers: breeze.Entity[];
+ var customersQuery = breeze.EntityQuery.fromEntities(customers);
+ var customersQuery = breeze.EntityQuery.fromEntities(customers)
+ .where("Region", breeze.FilterQueryOp.NotEquals, null);
+ var customerQuery = breeze.EntityQuery.fromEntities(customer);
+ var metadataStore: breeze.MetadataStore;
+ var empType = metadataStore.getEntityType("Employee");
+ var entityKey = new breeze.EntityKey( empType, 1);
+ var query = breeze.EntityQuery.fromEntityKey(entityKey);
+ var employee: breeze.Entity;
+ var entityKey = employee.entityAspect.getKey();
+ var query = breeze.EntityQuery.fromEntityKey(entityKey);
+ var ordersNavProp = employee.entityType.getProperty("Orders");
+ var query = breeze.EntityQuery.fromEntityNavigation(employee, ordersNavProp);
+ var query = new breeze.EntityQuery("Customers")
+ .orderBy("CompanyName");
+ var query = new breeze.EntityQuery("Customers")
+ .orderBy("Region, CompanyName");
+ var query = new breeze.EntityQuery("Products")
+ .orderBy("Category.CategoryName");
+ var query = new breeze.EntityQuery("Customers")
+ .orderBy("CompanyName desc");
+ var query = new breeze.EntityQuery("Customers")
+ .orderBy("Region desc, CompanyName desc");
+ var query = new breeze.EntityQuery("Customers")
+ .orderByDesc("CompanyName");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .select("CompanyName");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .select("Orders");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .select("CompanyName, Orders");
+ var query = new breeze.EntityQuery("Orders")
+ .where("Customer.CompanyName", "startsWith", "C")
+ .select("Customer.CompanyName, Customer, OrderDate");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .skip(5);
+ var query = new breeze.EntityQuery("Customers")
+ .take(5);
+ var query = new breeze.EntityQuery("Customers")
+ .top(5);
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders")
+ .using(em);
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders")
+ .using(breeze.MergeStrategy.PreserveChanges);
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders")
+ .using(breeze.FetchStrategy.FromLocalCache);
+ var adapter = new breeze.JsonResultsAdapter({ name: "foo", visitNode: function (x) { return x; } });
+ var q2 = query.using(adapter);
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", breeze.FilterQueryOp.StartsWith, "C");
+ var pred = new breeze.Predicate("CompanyName", breeze.FilterQueryOp.StartsWith, "C");
+ var query = new breeze.EntityQuery("Customers")
+ .where(pred);
+ var pred = breeze.Predicate.create("CompanyName", "startswith", "C").and("Region", breeze.FilterQueryOp.Equals, null);
+ var query = new breeze.EntityQuery("Customers")
+ .where(pred);
+ var query = new breeze.EntityQuery("Products")
+ .where("Category.CategoryName", "startswith", "S");
+ var query = new breeze.EntityQuery("Customers")
+ .where("toLower(CompanyName)", "startsWith", "c");
+ var query = new breeze.EntityQuery("Customers")
+ .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM");
+ var q2 = query.toType("foo").orderBy("foo2");
+}
+
+function test_entityState() {
+ var anEntity: breeze.Entity;
+ var es = anEntity.entityAspect.entityState;
+ return es.isAdded();
+ return es === breeze.EntityState.Added;
+ var es = anEntity.entityAspect.entityState;
+ return es.isAddedModifiedOrDeleted();
+ return es === breeze.EntityState.Added || es === breeze.EntityState.Modified || es === breeze.EntityState.Deleted;
+ var es = anEntity.entityAspect.entityState;
+ return es.isDeleted();
+ return es === breeze.EntityState.Deleted;
+ var es = anEntity.entityAspect.entityState;
+ return es.isDetached();
+ return es === breeze.EntityState.Detached;
+ var es = anEntity.entityAspect.entityState;
+ return es.isModified();
+ return es === breeze.EntityState.Modified;
+ var es = anEntity.entityAspect.entityState;
+ return es.isUnchanged();
+ return es === breeze.EntityState.Unchanged;
+ var es = anEntity.entityAspect.entityState;
+ return es.isUnchangedOrModified();
+
+ return es === breeze.EntityState.Unchanged || es === breeze.EntityState.Modified;
+}
+
+function test_entityType() {
+ var myMetadataStore: breeze.MetadataStore;
+ var myEntityType: breeze.EntityType;
+ var dataProperty1, dataProperty2, navigationProperty1: breeze.DataProperty;
+ var em1: breeze.EntityManager;
+ var entityManager = new breeze.EntityType({
+ metadataStore: myMetadataStore,
+ serviceName: "api/NorthwindIBModel",
+ name: "person",
+ namespace: "myAppNamespace"
+ });
+ myEntityType.addProperty(dataProperty1);
+ myEntityType.addProperty(dataProperty2);
+ myEntityType.addProperty(navigationProperty1);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var countryProp = custType.getProperty("Country");
+ var valFn = function (v) {
+ if (v == null) return true;
+ return (v.substring(0,2) === "US");
+ };
+ var countryValidator = new breeze.Validator("countryIsUS", valFn,
+ { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" });
+ custType.addValidator(countryValidator, countryProp);
+ countryProp.validators.push(countryValidator);
+ var someEntityLevelValidator: breeze.Validator;
+ custType.addValidator(someEntityLevelValidator);
+ custType.validators.push(someEntityLevelValidator);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var cust1 = custType.createEntity();
+ em1.addEntity(cust1);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var customerNameDataProp = custType.getDataProperty("CustomerName");
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var customerOrdersNavProp = custType.getDataProperty("Orders");
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var arrayOfProps = custType.getProperties();
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var companyNameProp = custType.getProperty("CompanyName");
+ var orderDetailType = em1.metadataStore.getEntityType("OrderDetail");
+ var companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName");
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var arrayOfPropNames = custType.getPropertyNames();
+ var custType = em1.metadataStore.getEntityType("Customer");
+ custType.setProperties({
+ autoGeneratedKeyType: breeze.AutoGeneratedKeyType.Identity,
+ defaultResourceName: "CustomersAndIncludedOrders"
+ });
+}
+
+//function test_enum() {
+// var prototype = {
+// nextDay: function () {
+// var nextIndex = (this.dayIndex + 1) % 7;
+// return DayOfWeek.getSymbols()[nextIndex];
+// }
+// };
+// var DayOfWeek = new core.Enum("DayOfWeek", prototype);
+// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 });
+// var symbol = DayOfWeek.Friday;
+// if (DayOfWeek.contains(symbol)) { }
+// var dayOfWeek = DayOfWeek.from("Thursday");
+// var symbols = DayOfWeek.getNames();
+// var symbols = DayOfWeek.getSymbols();
+// if (core.Enum.isSymbol(DayOfWeek.Wednesday)) { };
+// DayOfWeek.seal();
+// var name = DayOfWeek.Monday.getName();
+// var name = DayOfWeek.Monday.toString();
+
+
+// var prototype = {
+// nextDay: function () {
+// var nextIndex = (this.dayIndex + 1) % 7;
+// return DayOfWeek.getSymbols()[nextIndex];
+// }
+// };
+// var DayOfWeek = new core.Enum("DayOfWeek", prototype);
+// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 });
+// DayOfWeek.Tuesday = DayOfWeek.addSymbol({ dayIndex: 1 });
+// DayOfWeek.Wednesday = DayOfWeek.addSymbol({ dayIndex: 2 });
+// DayOfWeek.Thursday = DayOfWeek.addSymbol({ dayIndex: 3 });
+// DayOfWeek.Friday = DayOfWeek.addSymbol({ dayIndex: 4 });
+// DayOfWeek.Saturday = DayOfWeek.addSymbol({ dayIndex: 5, isWeekend: true });
+// DayOfWeek.Sunday = DayOfWeek.addSymbol({ dayIndex: 6, isWeekend: true });
+// DayOfWeek.seal();
+// DayOfWeek.Monday.nextDay() === DayOfWeek.Tuesday;
+// DayOfWeek.Sunday.nextDay() === DayOfWeek.Monday;
+// DayOfWeek.Tuesday.isWeekend === undefined;
+// DayOfWeek.Saturday.isWeekend == true;
+// DayOfWeek instanceof core.Enum;
+// core.Enum.isSymbol(DayOfWeek.Wednesday);
+// DayOfWeek.contains(DayOfWeek.Thursday);
+// DayOfWeek.Tuesday.parentEnum == DayOfWeek;
+// DayOfWeek.getSymbols().length === 7;
+// DayOfWeek.Friday.toString() === "Friday";
+//}
+
+function test_event() {
+ var myEntityManager: breeze.EntityManager;
+ var myEntity, person: breeze.Entity;
+ var salaryEvent = new core.Event("salaryEvent", person);
+ core.Event.enable("propertyChanged", myEntityManager, false);
+ core.Event.enable("propertyChanged", myEntityManager, true);
+ core.Event.enable("propertyChanged", myEntity.entityAspect, false);
+ core.Event.enable("propertyChanged", myEntity.entityAspect, null);
+ core.Event.enable("validationErrorsChanged", myEntityManager, function (em) {
+ return em.customTag === "blue";
+ });
+ core.Event.isEnabled("propertyChanged", myEntityManager);
+ salaryEvent.publish({ eventType: "payRaise", amount: 100 });
+ salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true);
+ salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true, function (error) { });
+ salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 });
+ salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 }, function (error) { });
+ salaryEvent.subscribe(function (eventArgs) {
+ if (eventArgs.eventType === "payRaise") { }
+ });
+ var order: breeze.Entity;
+ order.entityAspect.propertyChanged.subscribe(function (pcEvent) {
+ if (pcEvent.propertyName === "OrderDate") { }
+ });
+ var token = order.entityAspect.propertyChanged.subscribe(function (pcEvent) { });
+ order.entityAspect.propertyChanged.unsubscribe(token);
+}
+
+function test_localQueryComparisonOptions() {
+ var lqco = new breeze.LocalQueryComparisonOptions({
+ name: "caseSensitive-nonSQL",
+ isCaseSensitive: true,
+ usesSql92CompliantStringComparison: false
+ });
+ lqco.setAsDefault();
+ var ms = new breeze.MetadataStore({ localQueryComparisonOptions: lqco });
+ var em = new breeze.EntityManager({ metadataStore: ms });
+ var lqco = new breeze.LocalQueryComparisonOptions({
+ isCaseSensitive: false,
+ usesSql92CompliantStringComparison: true
+ });
+ lqco.setAsDefault();
+}
+
+function test_namingConventions() {
+ var namingConv = new breeze.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 nc = new breeze.NamingConvention({
+ serverPropertyNameToClient: function (x) {
+ return "xxx";
+ }
+ });
+ var ms = new breeze.MetadataStore({ namingConvention: namingConv });
+ var em = new breeze.EntityManager({ metadataStore: ms });
+ var namingConv = new breeze.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();
+}
+
+function test_navigationProperty() {
+ var homeAddressProp = new breeze.NavigationProperty({
+ name: "homeAddress",
+ entityTypeName: "Address:#myNamespace",
+ isScalar: true,
+ associationName: "address_person",
+ foreignKeyNames: ["homeAddressId"]
+ });
+ var homeAddressIdProp = new breeze.DataProperty({
+ name: "homeAddressId",
+ dataType: breeze.DataType.Int32
+ });
+ var personEntityType: breeze.EntityType;
+ personEntityType.addProperty(homeAddressProp);
+ personEntityType.addProperty(homeAddressIdProp);
+}
+
+function test_predicate() {
+ var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B");
+ var p1a = breeze.Predicate.create("CompanyName", "==", "City");
+ var p2a = p1a.and(p1a.not());
+ var query = new breeze.EntityQuery("Customers").where(p1);
+ var p2 = new breeze.Predicate("Region", breeze.FilterQueryOp.Equals, null);
+ var query = new breeze.EntityQuery("Customers").where(p2);
+ var dt = new Date(88, 9, 12);
+ var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+ var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+ var p3 = breeze.Predicate.create("Freight", ">", 100);
+ var newPred = p1.and(p2, p3);
+ var preds = [p2, p3];
+ var newPred = p1.and(preds);
+ var p4 = breeze.Predicate.create("ShipCity", "startswith", "F")
+ .and("Size", "gt", 2000);
+ var dt = new Date(88, 9, 12);
+ var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+ var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+ var p3 = breeze.Predicate.create("Freight", ">", 100);
+ var newPred = breeze.Predicate.and(p1, p2, p3);
+ var preds = [p1, p2, p3];
+ var newPred = breeze.Predicate.and(preds);
+ var p1 = breeze.Predicate.create("Freight", "gt", 100);
+ var predArgs: any[] = ["Freight", "gt", 100];
+ var p1 = breeze.Predicate.create(predArgs);
+ var p1 = new breeze.Predicate("Freight", "gt", 100);
+ var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B");
+ if (breeze.Predicate.isPredicate(p1)) { }
+ var p1 = breeze.Predicate.create("Freight", "gt", 100);
+ var not_p1 = breeze.Predicate.not(p1);
+ var not_p1 = p1.not();
+ var not_p1 = breeze.Predicate.create("Freight", "le", 100);
+ var dt = new Date(88, 9, 12);
+ var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+ var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+ var p3 = breeze.Predicate.create("Freight", ">", 100);
+ var newPred = breeze.Predicate.or(p1, p2, p3);
+ var preds = [p1, p2, p3];
+ var newPred = breeze.Predicate.or(preds);
+ var dt = new Date(88, 9, 12);
+ var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+ var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+ var p3 = breeze.Predicate.create("Freight", ">", 100);
+ var newPred = p1.and(p2, p3);
+ var preds = [p2, p3];
+ var newPred = p1.and(preds);
+ var p4 = breeze.Predicate.create("ShipCity", "startswith", "F")
+ .or("Size", "gt", 2000);
+}
+
+function test_queryOptions() {
+ var em1: breeze.EntityManager;
+ var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
+ em1.setProperties({ queryOptions: newQo });
+ var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
+ newQo.setAsDefault();
+ var queryOptions = em1.queryOptions.using(breeze.MergeStrategy.PreserveChanges);
+ var queryOptions = em1.queryOptions.using(breeze.FetchStrategy.FromLocalCache);
+ var queryOptions = em1.queryOptions.using({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
+}
+
+function test_validationOptions() {
+ var newVo = new breeze.ValidationOptions({ validateOnSave: false, validateOnAttach: false });
+ var em1: breeze.EntityManager;
+ em1.setProperties({ validationOptions: newVo });
+ var validationOptions = new breeze.ValidationOptions()
+ var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
+ newOptions.setAsDefault();
+ var validationOptions = new breeze.ValidationOptions();
+ var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
+}
+
+function test_validator() {
+ var valFn = function (v) {
+ if (v == null) return true;
+ return ( v.substr(0,2)=== "US");
+ };
+ var countryValidator = new breeze.Validator("countryIsUS", valFn, {
+ displayName: "Country",
+ messageTemplate: "'%displayName%' must start with 'US'"
+ });
+ var metadataStore: breeze.MetadataStore;
+ var custType = metadataStore.getEntityType("Customer");
+ var countryProp = custType.getProperty("Country");
+ countryProp.validators.push(countryValidator);
+ function isValidZipCode(value) {
+ var re = /^\d{5}([\-]\d{4})?$/;
+ return (re.test(value));
+ }
+ var valFn = function (v) {
+ if (v.getProperty("Country") === "USA") {
+ var postalCode = v.getProperty("PostalCode");
+ return isValidZipCode(postalCode);
+ }
+ return true;
+ };
+ var zipCodeValidator = new breeze.Validator("zipCodeValidator", valFn,
+ { messageTemplate: "For the US, this is not a valid PostalCode" });
+ var em1: breeze.EntityManager;
+ var custType = em1.metadataStore.getEntityType("Customer");
+ custType.validators.push(zipCodeValidator);
+ var numericRangeValidator = function (context) {
+ var valFn = function (v, ctx) {
+ if (v == null) return true;
+ if (typeof (v) !== "number") return false;
+ if (ctx.min != null && v < ctx.min) return false;
+ if (ctx.max != null && v > ctx.max) return false;
+ return true;
+ };
+ return new breeze.Validator("numericRange", valFn, {
+ messageTemplate: "'%displayName%' must be an integer between the values of %min% and %max%",
+ min: context.min,
+ max: context.max
+ });
+ };
+ freightProperty.validators.push(numericRangeValidator({ min: 100, max: 500 }));
+ var productType = em1.metadataStore.getEntityType("Product");
+ var discontinuedProperty = productType.getProperty("Discontinued");
+ discontinuedProperty.validators.push(breeze.Validator.bool());
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var freightProperty = orderType.getProperty("Freight");
+ regionProperty.validators.push(breeze.Validator.byte());
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var orderDateProperty = orderType.getProperty("OrderDate");
+ orderDateProperty.validators.push(breeze.Validator.date());
+ var v0 = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
+ v0.validate("adasdfasdf");
+ var errMessage = v0.getMessage();
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var customerIdProperty = custType.getProperty("CustomerID");
+ customerIdProperty.validators.push(breeze.Validator.guid());
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var freightProperty = orderType.getProperty("Freight");
+ freightProperty.validators.push(breeze.Validator.int16());
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var freightProperty = orderType.getProperty("Freight");
+ freightProperty.validators.push(breeze.Validator.int32());
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var freightProperty = orderType.getProperty("Freight");
+ freightProperty.validators.push(breeze.Validator.int64());
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var regionProperty = custType.getProperty("Region");
+ regionProperty.validators.push(breeze.Validator.maxLength({ maxLength: 5 }));
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var freightProperty = orderType.getProperty("Freight");
+ freightProperty.validators.push(breeze.Validator.number());
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var regionProperty = custType.getProperty("Region");
+ regionProperty.validators.push(breeze.Validator.required());
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var regionProperty = custType.getProperty("Region");
+ regionProperty.validators.push(breeze.Validator.string());
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var regionProperty = custType.getProperty("Region");
+ regionProperty.validators.push(breeze.Validator.stringLength({ minLength: 2, maxLength: 5 }));
+ var validator = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
+ var result = validator.validate("asdf");
+ var ok = result === null;
+ result = validator.validate("adasdfasdf");
+ var errMsg = result.errorMessage;
+ var context = result.context;
+ var sameValidator = result.validator;
+ var valFn = function (v) {
+ if (v == null) return true;
+ return (v.substr(0,2) === "US");
+ };
+ var countryValidator = new breeze.Validator("countryIsUS", valFn, { displayName: "Country" });
+ breeze.Validator.messageTemplates["countryIsUS"] = "'%displayName%' must start with 'US'";
+}
+
+function test_demo() {
+
+ var manager = new breeze.EntityManager('api/northwind');
+
+ var query = new breeze.EntityQuery()
+ .from("Employees");
+
+ manager.executeQuery(query).then(function (data) { });
+}
\ No newline at end of file
diff --git a/breeze/breeze-1.2.d.ts b/breeze/breeze-1.2.d.ts
new file mode 100644
index 000000000..264b36431
--- /dev/null
+++ b/breeze/breeze-1.2.d.ts
@@ -0,0 +1,779 @@
+// Type definitions for Breeze 1.2.7
+// Project: http://www.breezejs.com/
+// Definitions by: Boris Yankov ,
+// IdeaBlade
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Updated March 27 2013 - John Lantz (www.ideablade.com)
+
+
+declare module breezeCore {
+
+ interface ErrorCallback {
+ (error: Error): void;
+ }
+
+ interface IEnum {
+ contains(object: any): boolean;
+ fromName(name: string): EnumSymbol;
+ getNames(): string[];
+ getSymbols(): EnumSymbol[];
+ }
+
+ class Enum implements IEnum {
+ constructor (name: string, methodObj?: any);
+
+ addSymbol(propertiesObj?: any): EnumSymbol;
+ contains(object: any): boolean;
+ fromName(name: string): EnumSymbol;
+ getNames(): string[];
+ getSymbols(): EnumSymbol[];
+ static isSymbol(object: any): boolean;
+ seal(): void;
+ }
+
+ class EnumSymbol {
+ parentEnum: IEnum;
+
+ getName(): string;
+ toString(): string;
+ }
+
+ class Event {
+ constructor (name: string, publisher: any, defaultErrorCallback?: ErrorCallback);
+
+ static enable(eventName: string, target: any): void;
+ static enable(eventName: string, target: any, isEnabled: boolean): void;
+ static enable(eventName: string, target: any, isEnabled: Function): void;
+
+ static isEnabled(eventName: string, target: any): boolean;
+ publish(data: any, publishAsync?: boolean, errorCallback?: ErrorCallback): void;
+ publishAsync(data: any, errorCallback?: ErrorCallback): void;
+ subscribe(callback?: (data: any) => void ): number;
+ unsubscribe(unsubKey: number): boolean;
+ }
+}
+
+declare module breeze {
+
+ interface Entity {
+ entityAspect: EntityAspect;
+ entityType: EntityType;
+ }
+
+ interface ComplexObject {
+ complexAspect: ComplexAspect;
+ complexType: ComplexType;
+ }
+
+ interface IProperty {
+ name: string;
+ parentEntityType: EntityType;
+ validators: Validator[];
+ isDataProperty: boolean;
+ isNavigationProperty: boolean;
+ }
+
+ interface IStructuralType {
+ complexProperties: DataProperty[];
+ dataProperties: DataProperty[];
+ name: string;
+ namespace: string;
+ shortName: string;
+ unmappedProperties: DataProperty[];
+ validators: Validator[];
+ }
+
+ class AutoGeneratedKeyType {
+ static Identity: AutoGeneratedKeyType;
+ static KeyGenerator: AutoGeneratedKeyType;
+ static None: AutoGeneratedKeyType;
+ }
+
+ class ComplexAspect {
+ complexObject: ComplexObject;
+ entityAspect: EntityAspect;
+ parent: Object;
+ parentProperty: DataProperty;
+ propertyPath: string;
+ originalValues: Object;
+ }
+
+ class ComplexType implements IStructuralType {
+ complexProperties: DataProperty[];
+ dataProperties: DataProperty[];
+ name: string;
+ namespace: string;
+ shortName: string;
+ unmappedProperties: DataProperty[];
+ validators: Validator[];
+ addProperty(dataProperty: DataProperty);
+ getProperties(): DataProperty[];
+ }
+
+ class DataProperty implements IProperty {
+ complexTypeName: string;
+ concurrencyMode: string;
+ dataType: DataTypeSymbol;
+ defaultValue: any;
+ fixedLength: boolean;
+ isComplexProperty: boolean;
+ isDataProperty: boolean;
+ isNavigationProperty: boolean;
+ isNullable: boolean;
+ isPartOfKey: boolean;
+ isUnmapped: boolean;
+
+ maxLength: number;
+ name: string;
+ nameOnServer: string;
+ parentEntityType: EntityType;
+ relatedNavigationProperty: NavigationProperty;
+ validators: Validator[];
+ constructor (config: DataPropertyOptions);
+ }
+
+ interface DataPropertyOptions {
+ complexTypeName?: string;
+ concurrencyMode?: string;
+ dataType?: DataTypeSymbol;
+ defaultValue?: any;
+ fixedLength?: boolean;
+ isNullable?: boolean;
+ isPartOfKey?: boolean;
+ isUnmapped?: boolean;
+ maxLength?: number;
+ name?: string;
+ nameOnServer?: string;
+ validators?: Validator[];
+ }
+
+ class DataService {
+ adapterName: string;
+ hasServerMetadata: boolean;
+ serviceName: string;
+ jsonResultsAdapter: JsonResultsAdapter;
+ constructor(config: DataServiceOptions);
+ }
+
+ interface DataServiceOptions {
+ adapterName?: string;
+ hasServerMetadata?: boolean;
+ serviceName?: string;
+ jsonResultsAdapter?: JsonResultsAdapter;
+ }
+
+ class JsonResultsAdapter {
+ name: string;
+ extractResults: (data: {}) => {};
+ visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: boolean; };
+ constructor(config: {
+ name: string;
+ extractResults?: (data: {}) => {};
+ visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: boolean; };
+ });
+ }
+
+ interface QueryContext {
+ query: any; // how to also say it could be an EntityQuery or a string
+ entityManager: EntityManager;
+ jsonResultsAdapter: JsonResultsAdapter;
+ mergeStrategy: MergeStrategy;
+ }
+
+ interface NodeContext {
+ nodeType: string;
+ }
+
+
+
+ class DataTypeSymbol extends breezeCore.EnumSymbol {
+ defaultValue: any;
+ isNumeric: boolean;
+ }
+ interface DataType extends breezeCore.IEnum {
+ Binary: DataTypeSymbol;
+ Boolean: DataTypeSymbol;
+ Byte: DataTypeSymbol;
+ DateTime: DataTypeSymbol;
+ Decimal: DataTypeSymbol;
+ Double: DataTypeSymbol;
+ Guid: DataTypeSymbol;
+ Int16: DataTypeSymbol;
+ Int32: DataTypeSymbol;
+ Int64: DataTypeSymbol;
+ Single: DataTypeSymbol;
+ String: DataTypeSymbol;
+ Time: DataTypeSymbol;
+ Undefined: DataTypeSymbol;
+ toDataType(typeName: string): DataTypeSymbol;
+ parseDateFromServer(date: any): Date;
+
+ }
+ var DataType: DataType;
+
+ class EntityActionSymbol extends breezeCore.EnumSymbol {
+ }
+ interface EntityAction extends breezeCore.IEnum {
+ AcceptChanges: EntityActionSymbol;
+ Attach: EntityActionSymbol;
+ AttachOnImport: EntityActionSymbol;
+ AttachOnQuery: EntityActionSymbol;
+ Clear: EntityActionSymbol;
+ Detach: EntityActionSymbol;
+ EntityStateChange: EntityActionSymbol;
+ MergeOnImport: EntityActionSymbol;
+ MergeOnSave: EntityActionSymbol;
+ MergeOnQuery: EntityActionSymbol;
+ PropertyChange: EntityActionSymbol;
+ RejectChanges: EntityActionSymbol;
+ }
+ var EntityAction: EntityAction;
+
+ class EntityAspect {
+ entity: Entity;
+ entityManager: EntityManager;
+ entityState: EntityStateSymbol;
+ isBeingSaved: boolean;
+ originalValues: any;
+
+ propertyChanged: PropertyChangedEvent;
+ validationErrorsChanged: ValidationErrorsChangedEvent;
+
+ acceptChanges(): void;
+ addValidationError(validationError: ValidationError): void;
+ clearValidationErrors(): void;
+ getKey(forceRefresh?: boolean): EntityKey;
+
+ getValidationErrors(): ValidationError[];
+ getValidationErrors(property: string): ValidationError[];
+ getValidationErrors(property: IProperty): ValidationError[];
+
+ loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): Promise;
+ loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): Promise;
+
+ rejectChanges(): void;
+
+ removeValidationError(validator: Validator): void;
+ removeValidationError(validator: Validator, property: DataProperty): void;
+ removeValidationError(validator: Validator, property: NavigationProperty): void;
+
+ setDeleted(): void;
+ setModified(): void;
+ setUnchanged(): void;
+ setDetached(): boolean;
+ validateEntity(): boolean;
+
+ validateProperty(property: string, context?: any): boolean;
+ validateProperty(property: DataProperty, context?: any): boolean;
+ validateProperty(property: NavigationProperty, context?: any): boolean;
+ }
+
+ class PropertyChangedEventArgs {
+ entity: Entity;
+ propertyName: string;
+ oldValue: any;
+ newValue: any;
+ }
+
+ class PropertyChangedEvent extends breezeCore.Event {
+ subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number;
+ }
+
+ class ValidationErrorsChangedEventArgs {
+ entity: Entity;
+ added: ValidationError[];
+ removed: ValidationError[];
+ }
+
+ class ValidationErrorsChangedEvent extends breezeCore.Event {
+ subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number;
+ }
+
+ class EntityKey {
+ constructor (entityType: EntityType, keyValue: any);
+ constructor (entityType: EntityType, keyValues: any[]);
+
+ equals(entityKey: EntityKey): boolean;
+ static equals(k1: EntityKey, k2: EntityKey): boolean;
+ }
+
+ class EntityManager {
+ dataService: DataService;
+ keyGeneratorCtor: Function;
+ metadataStore: MetadataStore;
+ queryOptions: QueryOptions;
+ saveOptions: SaveOptions;
+ serviceName: string;
+ validationOptions: ValidationOptions;
+
+ entityChanged: EntityChangedEvent;
+ hasChangesChanged: HasChangesChangedEvent;
+
+ constructor (config?: EntityManagerOptions);
+ constructor (config?: string);
+
+ addEntity(entity: Entity): Entity;
+ attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity;
+ clear(): void;
+ createEmptyCopy(): EntityManager;
+ createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol) : Entity;
+ detachEntity(entity: Entity): boolean;
+ executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
+ executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
+
+ executeQueryLocally(query: EntityQuery): Entity[];
+ exportEntities(entities?: Entity[]): string;
+ fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: boolean): Promise;
+ fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: boolean): Promise;
+ fetchEntityByKey(entityKey: EntityKey): Promise;
+ fetchMetadata(callback?: (schema: any) => void , errorCallback?: breezeCore.ErrorCallback): Promise;
+ generateTempKeyValue(entity: Entity): any;
+ getChanges(): Entity[];
+ getChanges(entityTypeName: string): Entity[];
+ getChanges(entityTypeNames: string[]): Entity[];
+ getChanges(entityType: EntityType): Entity[];
+ getChanges(entityTypes: EntityType[]): Entity[];
+
+ getEntities(entityTypeName: string, entityState?: EntityStateSymbol): Entity[];
+ getEntities(entityTypeNames?: string[], entityState?: EntityStateSymbol): Entity[];
+ getEntities(entityTypeName?: string, entityStates?: EntityStateSymbol[]): Entity[];
+ getEntities(entityTypeNames?: string[], entityStates?: EntityStateSymbol[]): Entity[];
+
+ getEntities(entityType: EntityType, entityState?: EntityStateSymbol): Entity[];
+ getEntities(entityTypes?: EntityType[], entityState?: EntityStateSymbol): Entity[];
+ getEntities(entityType?: EntityType, entityStates?: EntityStateSymbol[]): Entity[];
+ getEntities(entityTypes?: EntityType[], entityStates?: EntityStateSymbol[]): Entity[];
+
+ getEntityByKey(typeName: string, keyValue: any): Entity;
+ getEntityByKey(typeName: string, keyValues: any[]): Entity;
+ getEntityByKey(entityKey: EntityKey): Entity;
+
+ hasChanges(): boolean;
+ hasChanges(entityTypeName: string): boolean;
+ hasChanges(entityTypeNames: string[]): boolean;
+ hasChanges(entityType: EntityType): boolean;
+ hasChanges(entityTypes: EntityType[]): boolean;
+
+ static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
+ importEntities(exportedString: any, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
+
+ rejectChanges(): Entity[];
+ saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Promise;
+ setProperties(config: EntityManagerProperties): void;
+
+ helper: {
+ unwrapInstance(structObj: Entity, isOData: boolean): any;
+ unwrapOriginalValues(target: Entity, metadataStore: MetadataStore, isOData: boolean): any;
+ unwrapChangedValues(target: Entity, metadataStore: MetadataStore, isOData: boolean): any;
+ getEntityKeyFromRawEntity(rawEntity: any, entityType: EntityType, isClient: boolean): EntityKey;
+ };
+ }
+
+ interface EntityManagerOptions {
+ serviceName?: string;
+ dataService?: DataService;
+ metadataStore?: MetadataStore;
+ queryOptions?: QueryOptions;
+ saveOptions?: SaveOptions;
+ validationOptions?: ValidationOptions;
+ keyGeneratorCtor?: Function;
+ }
+
+ interface EntityManagerProperties {
+ serviceName?: string;
+ dataService?: DataService;
+ queryOptions?: QueryOptions;
+ saveOptions?: SaveOptions;
+ validationOptions?: ValidationOptions;
+ keyGeneratorCtor?: Function;
+ }
+
+ interface ExecuteQuerySuccessCallback {
+ (data: { results: Entity[]; query: EntityQuery; XHR: XMLHttpRequest; }): void;
+ }
+
+ interface ExecuteQueryErrorCallback {
+ (error: { query: EntityQuery; XHR: XMLHttpRequest; }): void;
+ }
+
+ interface SaveChangesSuccessCallback {
+ (saveResult: { entities: Entity[]; keyMappings: any; XHR: XMLHttpRequest; }): void;
+ }
+
+ interface SaveChangesErrorCallback {
+ (error: { XHR: XMLHttpRequest; }): void;
+ }
+
+ class EntityChangedEventArgs {
+ entity: Entity;
+ entityAction: EntityActionSymbol;
+ args: Object;
+ }
+
+ class EntityChangedEvent extends breezeCore.Event {
+ subscribe(callback?: (data: EntityChangedEventArgs) => void ): number;
+ }
+
+ class HasChangesChangedEventArgs {
+ entityManager: EntityManager;
+ hasChanges: boolean;
+ }
+
+ class HasChangesChangedEvent extends breezeCore.Event {
+ subscribe(callback?: (data: HasChangesChangedEventArgs) => void ): number;
+ }
+
+ class EntityQuery {
+ entityManager: EntityManager;
+ orderByClause: OrderByClause;
+ parameters: Object;
+ queryOptions: QueryOptions;
+ resourceName: string;
+ skipCount: number;
+ takeCount: number;
+ wherePredicate: Predicate;
+
+ constructor (resourceName?: string);
+
+ execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
+ executeLocally(): Entity[];
+ expand(propertyPaths: string[]): EntityQuery;
+ expand(propertyPaths: string): EntityQuery;
+ static from(resourceName: string): EntityQuery;
+ from(resourceName: string): EntityQuery;
+ static fromEntities(entity: Entity): EntityQuery;
+ static fromEntities(entities: Entity[]): EntityQuery;
+ static fromEntityKey(entityKey: EntityKey): EntityQuery;
+ static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery;
+ inlineCount(enabled?: boolean): EntityQuery;
+ orderBy(propertyPaths: string): EntityQuery;
+ orderBy(propertyPaths: string[]): EntityQuery;
+ orderByDesc(propertyPaths: string): EntityQuery;
+ orderByDesc(propertyPaths: string[]): EntityQuery;
+ select(propertyPaths: string): EntityQuery;
+ select(propertyPaths: string[]): EntityQuery;
+ skip(count: number): EntityQuery;
+ take(count: number): EntityQuery;
+ top(count: number): EntityQuery;
+ toType(typeName: string): EntityQuery;
+ toType(type: EntityType): EntityQuery;
+
+ using(obj: EntityManager): EntityQuery;
+ using(obj: MergeStrategySymbol): EntityQuery;
+ using(obj: FetchStrategySymbol): EntityQuery;
+ using(obj: JsonResultsAdapter): EntityQuery;
+
+ where(predicate: Predicate): EntityQuery;
+ where(property: string, operator: string, value: any): EntityQuery;
+ where(property: string, operator: FilterQueryOpSymbol, value: any): EntityQuery;
+ where(predicate: FilterQueryOpSymbol): EntityQuery;
+ withParameters(params: Object): EntityQuery;
+ }
+
+ interface OrderByClause {
+ }
+
+ class EntityStateSymbol extends breezeCore.EnumSymbol {
+ isAdded(): boolean;
+ isAddedModifiedOrDeleted(): boolean;
+ isDeleted(): boolean;
+ isDetached(): boolean;
+ isModified(): boolean;
+ isUnchanged(): boolean;
+ isUnchangedOrModified(): boolean;
+ }
+ interface EntityState extends breezeCore.IEnum {
+ Added: EntityStateSymbol;
+ Deleted: EntityStateSymbol;
+ Detached: EntityStateSymbol;
+ Modified: EntityStateSymbol;
+ Unchanged: EntityStateSymbol;
+ }
+ var EntityState: EntityState;
+
+ class EntityType implements IStructuralType {
+ autoGeneratedKeyType: AutoGeneratedKeyType;
+ complexProperties: DataProperty[];
+ concurrencyProperties: DataProperty[];
+ dataProperties: DataProperty[];
+ defaultResourceName: string;
+ foreignKeyProperties: DataProperty[];
+ keyProperties: DataProperty[];
+ metadataStore: MetadataStore;
+ name: string;
+ namespace: string;
+ navigationProperties: NavigationProperty[];
+ shortName: string;
+ unmappedProperties: DataProperty[];
+ validators: Validator[];
+
+ constructor (config: MetadataStore);
+ constructor (config: EntityTypeOptions);
+
+ addProperty(property: IProperty): void;
+ addValidator(validator: Validator, property?: IProperty): void;
+ createEntity(initialValues?: Object): Entity;
+ getDataProperty(propertyName: string): DataProperty;
+ getEntityCtor(): Function;
+ getNavigationProperty(propertyName: string): NavigationProperty;
+ getProperties(): IProperty[];
+ getProperty(propertyPath: string, throwIfNotFound?: boolean): IProperty;
+ getPropertyNames(): string[];
+ setProperties(config: EntityTypeProperties): void;
+ toString(): string;
+ }
+
+ interface EntityTypeOptions {
+ shortName?: string;
+ namespace?: string;
+ autogeneratedKeyType?: AutoGeneratedKeyType;
+ defaultResourceName?: string;
+ }
+
+ interface EntityTypeProperties {
+ autogeneratedKeyType?: AutoGeneratedKeyType;
+ defaultResourceName?: string;
+ }
+
+ class FetchStrategySymbol extends breezeCore.EnumSymbol {
+ }
+ interface FetchStrategy extends breezeCore.IEnum {
+ FromLocalCache: FetchStrategySymbol;
+ FromServer: FetchStrategySymbol;
+ }
+ var FetchStrategy: FetchStrategy;
+
+ class FilterQueryOpSymbol extends breezeCore.EnumSymbol {
+ }
+ interface FilterQueryOp extends breezeCore.IEnum {
+ Contains: FilterQueryOpSymbol;
+ EndsWith: FilterQueryOpSymbol;
+ Equals: FilterQueryOpSymbol;
+ GreaterThan: FilterQueryOpSymbol;
+ GreaterThanOrEqual: FilterQueryOpSymbol;
+ LessThan: FilterQueryOpSymbol;
+ LessThanOrEqual: FilterQueryOpSymbol;
+ NotEquals: FilterQueryOpSymbol;
+ StartsWith: FilterQueryOpSymbol;
+ }
+ var FilterQueryOp: FilterQueryOp;
+
+ class LocalQueryComparisonOptions {
+ static caseInsensitiveSQL: LocalQueryComparisonOptions;
+ static defaultInstance: LocalQueryComparisonOptions;
+
+ constructor (config: { name?: string; isCaseSensitive?: boolean; usesSql92CompliantStringComparison?: boolean; });
+
+ setAsDefault(): void;
+ }
+
+ class MergeStrategySymbol extends breezeCore.EnumSymbol {
+ }
+ interface MergeStrategy extends breezeCore.IEnum {
+ OverwriteChanges: MergeStrategySymbol;
+ PreserveChanges: MergeStrategySymbol;
+ }
+ var MergeStrategy: MergeStrategy;
+
+ class MetadataStore {
+ namingConvention: NamingConvention;
+
+ constructor (config?: MetadataStoreOptions);
+ addDataService(dataService: DataService): void;
+ addEntityType(structuralType: IStructuralType): void;
+ exportMetadata(): string;
+ fetchMetadata(dataService: string, callback?: (data) => void , errorCallback?: breezeCore.ErrorCallback): Promise;
+ fetchMetadata(dataService: DataService, callback?: (data) => void , errorCallback?: breezeCore.ErrorCallback): Promise;
+ getDataService(serviceName: string): DataService;
+ getEntityType(entityTypeName: string, okIfNotFound?: boolean): IStructuralType;
+ getEntityTypes(): IStructuralType[];
+ hasMetadataFor(serviceName: string): boolean;
+ static importMetadata(exportedString: string): MetadataStore;
+ importMetadata(exportedString: string): MetadataStore;
+ isEmpty(): boolean;
+ registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void;
+ trackUnmappedType(entityCtor: Function, interceptor?: Function);
+ setEntityTypeForResourceName(resourceName: string, entityTypeOrName: string): void;
+ }
+
+ interface MetadataStoreOptions {
+ namingConvention?: NamingConvention;
+ localQueryComparisonOptions?: LocalQueryComparisonOptions;
+ }
+
+ class NamingConvention {
+ static camelCase: NamingConvention;
+ static defaultInstance: NamingConvention;
+ static none: NamingConvention;
+ name: string;
+
+ constructor (config: NamingConventionOptions);
+
+ clientPropertyNameToServer(clientPropertyName: string): string;
+ clientPropertyNameToServer(clientPropertyName: string, property: IProperty): string;
+
+ serverPropertyNameToClient(serverPropertyName: string): string;
+ serverPropertyNameToClient(serverPropertyName: string, property: IProperty): string;
+
+ setAsDefault();
+ }
+
+ interface NamingConventionOptions {
+ serverPropertyNameToClient?: (name: string) => string;
+ clientPropertyNameToServer?: (name: string) => string;
+ }
+
+ class NavigationProperty implements IProperty {
+ associationName: string;
+ entityType: EntityType;
+ foreignKeyNames: string[];
+ inverse: NavigationProperty;
+ isDataProperty: boolean;
+ isNavigationProperty: boolean;
+ isScalar: boolean;
+ name: string;
+ parentEntityType: EntityType;
+ relatedDataProperties: DataProperty[];
+ validators: Validator[];
+
+ constructor (config: NavigationPropertyOptions);
+ }
+
+ interface NavigationPropertyOptions {
+ name?: string;
+ nameOnServer?: string;
+ entityTypeName: string;
+ isScalar?: boolean;
+ associationName?: string;
+ foreignKeyNames?: string[];
+ foreignKeyNamesOnServer?: string[];
+ validators?: Validator[];
+ }
+
+ class Predicate {
+ constructor (property: string, operator: string, value: any, valueIsLiteral?: boolean);
+ constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean);
+
+ and: PredicateMethod;
+ static and: PredicateMethod;
+
+ static create: PredicateMethod;
+
+ static isPredicate(o: any): boolean;
+
+ static not(predicate: Predicate): Predicate;
+ not(): Predicate;
+
+ static or: PredicateMethod;
+ or: PredicateMethod;
+
+ toFunction(): Function;
+ toString(): string;
+ validate(entityType: EntityType): void;
+ }
+
+ interface PredicateMethod {
+ (predicates: Predicate[]): Predicate;
+ (...predicates: Predicate[]): Predicate;
+ (property: string, operator: string, value: any, valueIsLiteral?: boolean): Predicate;
+ (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean): Predicate;
+ }
+
+ class Promise {
+ fail(errorCallback: Function): Promise;
+ fin(finallyCallback: Function): Promise;
+ then(callback: Function): Promise;
+ }
+
+ class QueryOptions {
+ static defaultInstance: QueryOptions;
+ fetchStrategy: FetchStrategySymbol;
+ mergeStrategy: MergeStrategySymbol;
+
+ constructor (config?: QueryOptionsConfiguration);
+
+ setAsDefault(): void;
+ using(config: QueryOptionsConfiguration): QueryOptions;
+ using(config: MergeStrategySymbol): QueryOptions;
+ using(config: FetchStrategySymbol): QueryOptions;
+ }
+
+ interface QueryOptionsConfiguration {
+ fetchStrategy?: FetchStrategySymbol;
+ mergeStrategy?: MergeStrategySymbol;
+ }
+
+ class SaveOptions {
+ allowConcurrentSaves: boolean;
+ static defaultInstance: SaveOptions;
+
+ constructor (config?: { allowConcurrentSaves?: boolean; });
+
+ setAsDefault(): SaveOptions;
+ }
+
+ class ValidationError {
+ context: any;
+ errorMessage: string;
+ property: IProperty;
+ propertyName: string;
+ validator: Validator;
+
+ constructor (validator: Validator, context: any, errorMessage: string);
+ }
+
+ class ValidationOptions {
+ static defaultInstance: ValidationOptions;
+ validateOnAttach: boolean;
+ validateOnPropertyChange: boolean;
+ validateOnQuery: boolean;
+ validateOnSave: boolean;
+
+ constructor (config?: ValidationOptionsConfiguration);
+
+ setAsDefault(): ValidationOptions;
+ using(config: ValidationOptionsConfiguration): ValidationOptions;
+ }
+
+ interface ValidationOptionsConfiguration {
+ validateOnAttach?: boolean;
+ validateOnSave?: boolean;
+ validateOnQuery?: boolean;
+ validateOnPropertyChange?: boolean;
+ }
+
+ class Validator {
+ static messageTemplates: any;
+
+ constructor (name: string, validatorFn: ValidatorFunction, context?: any);
+
+ static bool(): Validator;
+ static byte(): Validator;
+ static date(): Validator;
+ static duration(): Validator;
+ getMessage(): string;
+ static guid(): Validator;
+ static int16(): Validator;
+ static int32(): Validator;
+ static int64(): Validator;
+ static maxLength(context: { maxLength: number; }): Validator;
+ static number(): Validator;
+ static required(): Validator;
+ static string(): Validator;
+ static stringLength(context: { maxLength: number; minLength: number; }): Validator;
+ validate(value: any, context?: any): ValidationError;
+ }
+
+ interface ValidatorFunction {
+ (value: any, context: ValidatorFunctionContext): void;
+ }
+
+ interface ValidatorFunctionContext {
+ value: any;
+ validatorName: string;
+ displayName: string;
+ messageTemplate: string;
+ message?: string;
+ }
+}
\ No newline at end of file
diff --git a/breeze/breeze-tests.ts b/breeze/breeze-tests.ts
index 2f4dab1d1..c9d727b60 100644
--- a/breeze/breeze-tests.ts
+++ b/breeze/breeze-tests.ts
@@ -1,797 +1,876 @@
-///
-
-import core = breezeCore;
-
-function test_dataType() {
- var typ = breeze.DataType.DateTime;
- var nm = typ.getName();
- var isNumber = typ.isNumeric;
- var dv = typ.defaultValue;
- var symbs = breeze.DataType.getSymbols();
- var x = typ.parentEnum === breeze.DataType;
- var isFalse = breeze.DataType.contains(breeze.DataType.Double);
- var dt = breeze.DataType.fromName("Decimal");
-
-}
-
-function test_dataProperty() {
- var lastNameProp = new breeze.DataProperty({
- name: "lastName",
- dataType: breeze.DataType.String,
- isNullable: true,
- maxLength: 20
- });
- var personEntityType: breeze.EntityType;
- personEntityType.addProperty(lastNameProp);
-}
-
-function test_dataService() {
- var ds = new breeze.DataService({
- serviceName: "api/NorthwindIBModel",
- hasServerMetadata: true
- });
- var em = new breeze.EntityManager({
- dataService: ds
- });
-
-}
-
-function test_entityAspect() {
- var order: breeze.Entity;
- order.entityAspect.acceptChanges();
- var entityKey = order.entityAspect.getKey();
- var valErrors = order.entityAspect.getValidationErrors();
- var orderDateErrors = order.entityAspect.getValidationErrors("OrderDate");
- var orderDateProperty = order.entityType.getProperty("OrderDate");
- var orderDateErrors = order.entityAspect.getValidationErrors(orderDateProperty);
- order.entityAspect.loadNavigationProperty("Orders").then(function (data) {
- var orders = data.results;
- }).fail(function (exception) { });
- order.entityAspect.rejectChanges();
- order.entityAspect.setDeleted();
- order.entityAspect.setModified();
- order.entityAspect.setUnchanged();
- var isOk = order.entityAspect.validateEntity();
- if (!isOk) {
- var errors = order.entityAspect.getValidationErrors();
- }
- var isOk = order.entityAspect.validateProperty("Order");
- var orderDateProperty = order.entityType.getProperty("OrderDate");
- //var isOk = order.entityAspect.validateProperty(OrderDateProperty);
- order.entityAspect.propertyChanged.subscribe(function (propertyChangedArgs) {
- var entity = propertyChangedArgs.entity;
- var propertyNameChanged = propertyChangedArgs.propertyName;
- var oldValue = propertyChangedArgs.oldValue;
- var newValue = propertyChangedArgs.newValue;
- });
- order.entityAspect.validationErrorsChanged.subscribe(function (validationChangeArgs) {
- var entity = validationChangeArgs.entity;
- var errorsAdded = validationChangeArgs.added;
- var errorsCleared = validationChangeArgs.removed;
- });
-
-}
-
-function test_entityKey() {
- var em1: breeze.EntityManager;
- var employee1: breeze.Entity;
- var empType = em1.metadataStore.getEntityType("Employee");
- var entityKey = new breeze.EntityKey( empType, 1);
- var empKey = employee1.entityAspect.getKey();
- var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory");
- var empTerrKey = new breeze.EntityKey( empTerrType, [1, 77]);
- var empType = em1.metadataStore.getEntityType("Employee");
- var empKey1 = new breeze.EntityKey( empType, 1);
- var empKey2 = employee1.entityAspect.getKey();
- if (empKey1.equals(empKey2)) { }
- if (breeze.EntityKey.equals(empKey1, empKey2)) { }
-}
-
-function test_metadataStore() {
- var ms = new breeze.MetadataStore();
- var entityManager = new breeze.EntityManager({
- serviceName: "api/NorthwindIBModel",
- metadataStore: ms
- });
- var em1: breeze.EntityManager;
- em1.setProperties({ metadataStore: ms });
- var metadataAsString = ms.exportMetadata();
- window.localStorage.setItem("metadata", metadataAsString);
- var metadataFromStorage = window.localStorage.getItem("metadata");
- var newMetadataStore = new breeze.MetadataStore();
- newMetadataStore.importMetadata(metadataFromStorage);
- var ms = new breeze.MetadataStore();
- ms.fetchMetadata("api/NorthwindIBModel")
- .then(function (rawMetadata) { })
- .fail(function (exception) { });
- var odType = em1.metadataStore.getEntityType("OrderDetail");
- var badType = em1.metadataStore.getEntityType("Foo", false);
- var allTypes = em1.metadataStore.getEntityTypes();
- if (!em1.metadataStore.hasMetadataFor("api/NorthwindIBModel")) { }
- var metadataAsString = ms.exportMetadata();
- window.localStorage.setItem("metadata", metadataAsString);
- var metadataFromStorage = window.localStorage.getItem("metadata");
- var newMetadataStore = breeze.MetadataStore.importMetadata(metadataFromStorage);
- var metadataAsString = ms.exportMetadata();
- window.localStorage.setItem("metadata", metadataAsString);
- var metadataFromStorage = window.localStorage.getItem("metadata");
- var newMetadataStore = new breeze.MetadataStore();
- newMetadataStore.importMetadata(metadataFromStorage);
- if (em1.metadataStore.isEmpty()) { }
- var Customer = function () {
- this.miscData = "asdf";
- }
- em1.metadataStore.registerEntityTypeCtor("Customer", Customer);
-}
-
-function test_entityManager() {
- var entityManager = new breeze.EntityManager("api/NorthwindIBModel");
- var em1 = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
- var metadataStore = new breeze.MetadataStore();
- var entityManager = new breeze.EntityManager({
- serviceName: "api/NorthwindIBModel",
- metadataStore: metadataStore
- });
-
- return new breeze.QueryOptions({
- mergeStrategy: null,
- fetchStrategy: this.fetchStrategy
- });
- var queryOptions = new breeze.QueryOptions({
- mergeStrategy: breeze.MergeStrategy.OverwriteChanges,
- fetchStrategy: breeze.FetchStrategy.FromServer
- });
- var validationOptions = new breeze.ValidationOptions({
- validateOnAttach: true,
- validateOnSave: true,
- validateOnQuery: false
- });
- var entityManager = new breeze.EntityManager({
- serviceName: "api/NorthwindIBModel",
- queryOptions: queryOptions,
- validationOptions: validationOptions
- });
- var custType = em1.metadataStore.getEntityType("Customer");
- var cust1 = custType.createEntity();
- em1.addEntity(cust1);
-
- var cust2 = em1.createEntity("Customer", { companyName: "foo" });
- var cust3 = em1.createEntity("foo", { xxx: 3 }, breeze.EntityState.Added);
-
- em1.attachEntity(cust1, breeze.EntityState.Added);
- em1.clear();
- var em2 = em1.createEmptyCopy();
- em1.detachEntity(cust1);
- var serviceName: string;
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders");
- em.executeQuery(query)
- .then(function (data) {
- var orders = data.results;
- }).fail(function (err) {
- });
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders");
- em.executeQuery(query,
- function (data) {
- var orders = data.results;
- },
- function (err) {
- });
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders").using(em);
- query.execute()
- .then(function (data) {
- var orders = data.results;
- }).fail(function (err) {
- });
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders");
- var orders = em.executeQueryLocally(query);
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders").using(breeze.FetchStrategy.FromLocalCache);
- em.executeQuery(query)
- .then(function (data) {
- var orders = data.results;
- }).fail(function (err) {
- });
- var bundle = em1.exportEntities();
- window.localStorage.setItem("myEntityManager", bundle);
- var bundleFromStorage = window.localStorage.getItem("myEntityManager");
- var em2 = new breeze.EntityManager({
- serviceName: em1.serviceName,
- metadataStore: em1.metadataStore
- });
- em2.importEntities(bundleFromStorage);
- var entitiesToExport: breeze.Entity[];
- var bundle = em1.exportEntities(entitiesToExport);
- em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges });
- var em1 = new breeze.EntityManager("api/NorthwindIBModel");
- em1.fetchMetadata()
- .then(function () {
- var metadataStore = em1.metadataStore;
- })
- .fail(function (exception) {
- });
- var employeeType = em1.metadataStore.getEntityType("Employee");
- var employeeKey = new breeze.EntityKey( employeeType, 1);
- var employee = em1.fetchEntityByKey(employeeKey);
- var emp2 = em1.fetchEntityByKey("Employee", 6);
- var emp3 = em1.fetchEntityByKey("Entityee", [6]);
- var custType = em1.metadataStore.getEntityType("Customer");
- var custumer = custType.createEntity();
- var customerId = em.generateTempKeyValue(custumer);
- em1.saveChanges()
- .then(function (data) {
- var sameCust1 = data.results[0];
- });
- var changedEntities = em1.getChanges();
- var custType = em1.metadataStore.getEntityType("Customer");
- var changedCustomers = em1.getChanges(custType);
- var custType = em1.metadataStore.getEntityType("Customer");
- var orderType = em1.metadataStore.getEntityType("Order");
- var changedCustomersAndOrders = em1.getChanges([custType, orderType]);
- var entities = em1.getEntities();
- var custType = em1.metadataStore.getEntityType("Customer");
- var customers = em1.getEntities(custType);
- var custType = em1.metadataStore.getEntityType("Customer");
- var orderType = em1.metadataStore.getEntityType("Order");
- var customersAndOrders = em1.getChanges([custType, orderType]);
- var custType = em1.metadataStore.getEntityType("Customer");
- var orderType = em1.metadataStore.getEntityType("Order");
- var addedCustomersAndOrders = em1.getEntities([custType, orderType], breeze.EntityState.Added);
- if (em1.hasChanges()) { }
- var custType = em1.metadataStore.getEntityType("Customer");
- if (em1.hasChanges(custType)) { }
- var custType = em1.metadataStore.getEntityType("Customer");
- var orderType = em1.metadataStore.getEntityType("Order");
- if (em1.hasChanges([custType, orderType])) { };
-
- var bundle = em1.exportEntities();
- window.localStorage.setItem("myEntityManager", bundle);
- var bundleFromStorage = window.localStorage.getItem("myEntityManager");
- var em2 = breeze.EntityManager.importEntities(bundleFromStorage);
- var bundle = em1.exportEntities();
- var em2 = new breeze.EntityManager({
- serviceName: em1.serviceName,
- metadataStore: em1.metadataStore
- });
- em2.importEntities(bundle);
- var bundle = em1.exportEntities();
- em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges });
- em.saveChanges().then(function (saveResult) {
- var savedEntities = saveResult.entities;
- var keyMappings = saveResult.keyMappings;
- }).fail(function (e) {
- });
- var saveOptions = new breeze.SaveOptions({ allowConcurrentSaves: true });
- var entitiesToSave: breeze.Entity[];
- em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult) {
- var savedEntities = saveResult.entities;
- var keyMappings = saveResult.keyMappings;
- }).fail(function (e) {
- });
- em.saveChanges(entitiesToSave, null,
- function (saveResult) {
- var savedEntities = saveResult.entities;
- var keyMappings = saveResult.keyMappings;
- }, function (e) { }
- );
- em1.setProperties({
- serviceName: "api/foo",
- });
- var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
- em.entityChanged.subscribe(function (changeArgs) {
- var action = changeArgs.entityAction;
- var entity = changeArgs.entity;
- });
- var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
- em.hasChangesChanged.subscribe(function (args) {
- var hasChanges = args.hasChanges;
- var entityManager = args.entityManager;
- });
-}
-
-function test_entityQuery() {
- var query = new breeze.EntityQuery("Customers");
- var query = new breeze.EntityQuery("Customers")
- .where("CompanyName", "startsWith", "C")
- .orderBy("Region");
- var serviceName: string;
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders").using(em);
- query.execute()
- .then(function (data) { })
- .fail(function (err) { });
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders").using(em);
- query.execute(
- function (data) {
- var orders = data.results;
- },
- function (err) { });
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders");
- em.executeQuery(query)
- .then(function (data) {
- var orders = data.results;
- }).fail(function (err) {
- });
- var query = new breeze.EntityQuery("Orders").using(em);
- var orders = query.executeLocally();
- var query = new breeze.EntityQuery("Customers")
- .where("CompanyName", "startsWith", "C")
- .expand("Orders");
- var query = new breeze.EntityQuery("Orders")
- .expand("Customer, Employee");
- var query = new breeze.EntityQuery("Orders")
- .expand("Customer, OrderDetails, OrderDetails.Product");
- var query = breeze.EntityQuery.from("Customers");
- var query = new breeze.EntityQuery("Customers");
- var query = new breeze.EntityQuery().from("Customers");
- var customer: breeze.Entity;
- var customers: breeze.Entity[];
- var customersQuery = breeze.EntityQuery.fromEntities(customers);
- var customersQuery = breeze.EntityQuery.fromEntities(customers)
- .where("Region", breeze.FilterQueryOp.NotEquals, null);
- var customerQuery = breeze.EntityQuery.fromEntities(customer);
- var metadataStore: breeze.MetadataStore;
- var empType = metadataStore.getEntityType("Employee");
- var entityKey = new breeze.EntityKey( empType, 1);
- var query = breeze.EntityQuery.fromEntityKey(entityKey);
- var employee: breeze.Entity;
- var entityKey = employee.entityAspect.getKey();
- var query = breeze.EntityQuery.fromEntityKey(entityKey);
- var ordersNavProp = employee.entityType.getProperty("Orders");
- var query = breeze.EntityQuery.fromEntityNavigation(employee, ordersNavProp);
- var query = new breeze.EntityQuery("Customers")
- .orderBy("CompanyName");
- var query = new breeze.EntityQuery("Customers")
- .orderBy("Region, CompanyName");
- var query = new breeze.EntityQuery("Products")
- .orderBy("Category.CategoryName");
- var query = new breeze.EntityQuery("Customers")
- .orderBy("CompanyName desc");
- var query = new breeze.EntityQuery("Customers")
- .orderBy("Region desc, CompanyName desc");
- var query = new breeze.EntityQuery("Customers")
- .orderByDesc("CompanyName");
- var query = new breeze.EntityQuery("Customers")
- .where("CompanyName", "startsWith", "C")
- .select("CompanyName");
- var query = new breeze.EntityQuery("Customers")
- .where("CompanyName", "startsWith", "C")
- .select("Orders");
- var query = new breeze.EntityQuery("Customers")
- .where("CompanyName", "startsWith", "C")
- .select("CompanyName, Orders");
- var query = new breeze.EntityQuery("Orders")
- .where("Customer.CompanyName", "startsWith", "C")
- .select("Customer.CompanyName, Customer, OrderDate");
- var query = new breeze.EntityQuery("Customers")
- .where("CompanyName", "startsWith", "C")
- .skip(5);
- var query = new breeze.EntityQuery("Customers")
- .take(5);
- var query = new breeze.EntityQuery("Customers")
- .top(5);
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders")
- .using(em);
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders")
- .using(breeze.MergeStrategy.PreserveChanges);
- var em = new breeze.EntityManager(serviceName);
- var query = new breeze.EntityQuery("Orders")
- .using(breeze.FetchStrategy.FromLocalCache);
- var adapter = new breeze.JsonResultsAdapter({ name: "foo", visitNode: function (x) { return x; } });
- var q2 = query.using(adapter);
- var query = new breeze.EntityQuery("Customers")
- .where("CompanyName", "startsWith", "C");
- var query = new breeze.EntityQuery("Customers")
- .where("CompanyName", breeze.FilterQueryOp.StartsWith, "C");
- var pred = new breeze.Predicate("CompanyName", breeze.FilterQueryOp.StartsWith, "C");
- var query = new breeze.EntityQuery("Customers")
- .where(pred);
- var pred = breeze.Predicate.create("CompanyName", "startswith", "C").and("Region", breeze.FilterQueryOp.Equals, null);
- var query = new breeze.EntityQuery("Customers")
- .where(pred);
- var query = new breeze.EntityQuery("Products")
- .where("Category.CategoryName", "startswith", "S");
- var query = new breeze.EntityQuery("Customers")
- .where("toLower(CompanyName)", "startsWith", "c");
- var query = new breeze.EntityQuery("Customers")
- .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM");
- var q2 = query.toType("foo").orderBy("foo2");
-}
-
-function test_entityState() {
- var anEntity: breeze.Entity;
- var es = anEntity.entityAspect.entityState;
- return es.isAdded();
- return es === breeze.EntityState.Added;
- var es = anEntity.entityAspect.entityState;
- return es.isAddedModifiedOrDeleted();
- return es === breeze.EntityState.Added || es === breeze.EntityState.Modified || es === breeze.EntityState.Deleted;
- var es = anEntity.entityAspect.entityState;
- return es.isDeleted();
- return es === breeze.EntityState.Deleted;
- var es = anEntity.entityAspect.entityState;
- return es.isDetached();
- return es === breeze.EntityState.Detached;
- var es = anEntity.entityAspect.entityState;
- return es.isModified();
- return es === breeze.EntityState.Modified;
- var es = anEntity.entityAspect.entityState;
- return es.isUnchanged();
- return es === breeze.EntityState.Unchanged;
- var es = anEntity.entityAspect.entityState;
- return es.isUnchangedOrModified();
-
- return es === breeze.EntityState.Unchanged || es === breeze.EntityState.Modified;
-}
-
-function test_entityType() {
- var myMetadataStore: breeze.MetadataStore;
- var myEntityType: breeze.EntityType;
- var dataProperty1, dataProperty2, navigationProperty1: breeze.DataProperty;
- var em1: breeze.EntityManager;
- var entityManager = new breeze.EntityType({
- metadataStore: myMetadataStore,
- serviceName: "api/NorthwindIBModel",
- name: "person",
- namespace: "myAppNamespace"
- });
- myEntityType.addProperty(dataProperty1);
- myEntityType.addProperty(dataProperty2);
- myEntityType.addProperty(navigationProperty1);
- var custType = em1.metadataStore.getEntityType("Customer");
- var countryProp = custType.getProperty("Country");
- var valFn = function (v) {
- if (v == null) return true;
- return (v.substring(0,2) === "US");
- };
- var countryValidator = new breeze.Validator("countryIsUS", valFn,
- { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" });
- custType.addValidator(countryValidator, countryProp);
- countryProp.validators.push(countryValidator);
- var someEntityLevelValidator: breeze.Validator;
- custType.addValidator(someEntityLevelValidator);
- custType.validators.push(someEntityLevelValidator);
- var custType = em1.metadataStore.getEntityType("Customer");
- var cust1 = custType.createEntity();
- em1.addEntity(cust1);
- var custType = em1.metadataStore.getEntityType("Customer");
- var customerNameDataProp = custType.getDataProperty("CustomerName");
- var custType = em1.metadataStore.getEntityType("Customer");
- var customerOrdersNavProp = custType.getDataProperty("Orders");
- var custType = em1.metadataStore.getEntityType("Customer");
- var arrayOfProps = custType.getProperties();
- var custType = em1.metadataStore.getEntityType("Customer");
- var companyNameProp = custType.getProperty("CompanyName");
- var orderDetailType = em1.metadataStore.getEntityType("OrderDetail");
- var companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName");
- var custType = em1.metadataStore.getEntityType("Customer");
- var arrayOfPropNames = custType.getPropertyNames();
- var custType = em1.metadataStore.getEntityType("Customer");
- custType.setProperties({
- autoGeneratedKeyType: breeze.AutoGeneratedKeyType.Identity,
- defaultResourceName: "CustomersAndIncludedOrders"
- });
-}
-
-//function test_enum() {
-// var prototype = {
-// nextDay: function () {
-// var nextIndex = (this.dayIndex + 1) % 7;
-// return DayOfWeek.getSymbols()[nextIndex];
-// }
-// };
-// var DayOfWeek = new core.Enum("DayOfWeek", prototype);
-// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 });
-// var symbol = DayOfWeek.Friday;
-// if (DayOfWeek.contains(symbol)) { }
-// var dayOfWeek = DayOfWeek.from("Thursday");
-// var symbols = DayOfWeek.getNames();
-// var symbols = DayOfWeek.getSymbols();
-// if (core.Enum.isSymbol(DayOfWeek.Wednesday)) { };
-// DayOfWeek.seal();
-// var name = DayOfWeek.Monday.getName();
-// var name = DayOfWeek.Monday.toString();
-
-
-// var prototype = {
-// nextDay: function () {
-// var nextIndex = (this.dayIndex + 1) % 7;
-// return DayOfWeek.getSymbols()[nextIndex];
-// }
-// };
-// var DayOfWeek = new core.Enum("DayOfWeek", prototype);
-// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 });
-// DayOfWeek.Tuesday = DayOfWeek.addSymbol({ dayIndex: 1 });
-// DayOfWeek.Wednesday = DayOfWeek.addSymbol({ dayIndex: 2 });
-// DayOfWeek.Thursday = DayOfWeek.addSymbol({ dayIndex: 3 });
-// DayOfWeek.Friday = DayOfWeek.addSymbol({ dayIndex: 4 });
-// DayOfWeek.Saturday = DayOfWeek.addSymbol({ dayIndex: 5, isWeekend: true });
-// DayOfWeek.Sunday = DayOfWeek.addSymbol({ dayIndex: 6, isWeekend: true });
-// DayOfWeek.seal();
-// DayOfWeek.Monday.nextDay() === DayOfWeek.Tuesday;
-// DayOfWeek.Sunday.nextDay() === DayOfWeek.Monday;
-// DayOfWeek.Tuesday.isWeekend === undefined;
-// DayOfWeek.Saturday.isWeekend == true;
-// DayOfWeek instanceof core.Enum;
-// core.Enum.isSymbol(DayOfWeek.Wednesday);
-// DayOfWeek.contains(DayOfWeek.Thursday);
-// DayOfWeek.Tuesday.parentEnum == DayOfWeek;
-// DayOfWeek.getSymbols().length === 7;
-// DayOfWeek.Friday.toString() === "Friday";
-//}
-
-function test_event() {
- var myEntityManager: breeze.EntityManager;
- var myEntity, person: breeze.Entity;
- var salaryEvent = new core.Event("salaryEvent", person);
- core.Event.enable("propertyChanged", myEntityManager, false);
- core.Event.enable("propertyChanged", myEntityManager, true);
- core.Event.enable("propertyChanged", myEntity.entityAspect, false);
- core.Event.enable("propertyChanged", myEntity.entityAspect, null);
- core.Event.enable("validationErrorsChanged", myEntityManager, function (em) {
- return em.customTag === "blue";
- });
- core.Event.isEnabled("propertyChanged", myEntityManager);
- salaryEvent.publish({ eventType: "payRaise", amount: 100 });
- salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true);
- salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true, function (error) { });
- salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 });
- salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 }, function (error) { });
- salaryEvent.subscribe(function (eventArgs) {
- if (eventArgs.eventType === "payRaise") { }
- });
- var order: breeze.Entity;
- order.entityAspect.propertyChanged.subscribe(function (pcEvent) {
- if (pcEvent.propertyName === "OrderDate") { }
- });
- var token = order.entityAspect.propertyChanged.subscribe(function (pcEvent) { });
- order.entityAspect.propertyChanged.unsubscribe(token);
-}
-
-function test_localQueryComparisonOptions() {
- var lqco = new breeze.LocalQueryComparisonOptions({
- name: "caseSensitive-nonSQL",
- isCaseSensitive: true,
- usesSql92CompliantStringComparison: false
- });
- lqco.setAsDefault();
- var ms = new breeze.MetadataStore({ localQueryComparisonOptions: lqco });
- var em = new breeze.EntityManager({ metadataStore: ms });
- var lqco = new breeze.LocalQueryComparisonOptions({
- isCaseSensitive: false,
- usesSql92CompliantStringComparison: true
- });
- lqco.setAsDefault();
-}
-
-function test_namingConventions() {
- var namingConv = new breeze.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 nc = new breeze.NamingConvention({
- serverPropertyNameToClient: function (x) {
- return "xxx";
- }
- });
- var ms = new breeze.MetadataStore({ namingConvention: namingConv });
- var em = new breeze.EntityManager({ metadataStore: ms });
- var namingConv = new breeze.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();
-}
-
-function test_navigationProperty() {
- var homeAddressProp = new breeze.NavigationProperty({
- name: "homeAddress",
- entityTypeName: "Address:#myNamespace",
- isScalar: true,
- associationName: "address_person",
- foreignKeyNames: ["homeAddressId"]
- });
- var homeAddressIdProp = new breeze.DataProperty({
- name: "homeAddressId",
- dataType: breeze.DataType.Int32
- });
- var personEntityType: breeze.EntityType;
- personEntityType.addProperty(homeAddressProp);
- personEntityType.addProperty(homeAddressIdProp);
-}
-
-function test_predicate() {
- var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B");
- var p1a = breeze.Predicate.create("CompanyName", "==", "City");
- var p2a = p1a.and(p1a.not());
- var query = new breeze.EntityQuery("Customers").where(p1);
- var p2 = new breeze.Predicate("Region", breeze.FilterQueryOp.Equals, null);
- var query = new breeze.EntityQuery("Customers").where(p2);
- var dt = new Date(88, 9, 12);
- var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
- var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
- var p3 = breeze.Predicate.create("Freight", ">", 100);
- var newPred = p1.and(p2, p3);
- var preds = [p2, p3];
- var newPred = p1.and(preds);
- var p4 = breeze.Predicate.create("ShipCity", "startswith", "F")
- .and("Size", "gt", 2000);
- var dt = new Date(88, 9, 12);
- var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
- var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
- var p3 = breeze.Predicate.create("Freight", ">", 100);
- var newPred = breeze.Predicate.and(p1, p2, p3);
- var preds = [p1, p2, p3];
- var newPred = breeze.Predicate.and(preds);
- var p1 = breeze.Predicate.create("Freight", "gt", 100);
- var predArgs: any[] = ["Freight", "gt", 100];
- var p1 = breeze.Predicate.create(predArgs);
- var p1 = new breeze.Predicate("Freight", "gt", 100);
- var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B");
- if (breeze.Predicate.isPredicate(p1)) { }
- var p1 = breeze.Predicate.create("Freight", "gt", 100);
- var not_p1 = breeze.Predicate.not(p1);
- var not_p1 = p1.not();
- var not_p1 = breeze.Predicate.create("Freight", "le", 100);
- var dt = new Date(88, 9, 12);
- var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
- var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
- var p3 = breeze.Predicate.create("Freight", ">", 100);
- var newPred = breeze.Predicate.or(p1, p2, p3);
- var preds = [p1, p2, p3];
- var newPred = breeze.Predicate.or(preds);
- var dt = new Date(88, 9, 12);
- var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
- var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
- var p3 = breeze.Predicate.create("Freight", ">", 100);
- var newPred = p1.and(p2, p3);
- var preds = [p2, p3];
- var newPred = p1.and(preds);
- var p4 = breeze.Predicate.create("ShipCity", "startswith", "F")
- .or("Size", "gt", 2000);
-}
-
-function test_queryOptions() {
- var em1: breeze.EntityManager;
- var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
- em1.setProperties({ queryOptions: newQo });
- var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
- newQo.setAsDefault();
- var queryOptions = em1.queryOptions.using(breeze.MergeStrategy.PreserveChanges);
- var queryOptions = em1.queryOptions.using(breeze.FetchStrategy.FromLocalCache);
- var queryOptions = em1.queryOptions.using({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
-}
-
-function test_validationOptions() {
- var newVo = new breeze.ValidationOptions({ validateOnSave: false, validateOnAttach: false });
- var em1: breeze.EntityManager;
- em1.setProperties({ validationOptions: newVo });
- var validationOptions = new breeze.ValidationOptions()
- var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
- newOptions.setAsDefault();
- var validationOptions = new breeze.ValidationOptions();
- var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
-}
-
-function test_validator() {
- var valFn = function (v) {
- if (v == null) return true;
- return ( v.substr(0,2)=== "US");
- };
- var countryValidator = new breeze.Validator("countryIsUS", valFn, {
- displayName: "Country",
- messageTemplate: "'%displayName%' must start with 'US'"
- });
- var metadataStore: breeze.MetadataStore;
- var custType = metadataStore.getEntityType("Customer");
- var countryProp = custType.getProperty("Country");
- countryProp.validators.push(countryValidator);
- function isValidZipCode(value) {
- var re = /^\d{5}([\-]\d{4})?$/;
- return (re.test(value));
- }
- var valFn = function (v) {
- if (v.getProperty("Country") === "USA") {
- var postalCode = v.getProperty("PostalCode");
- return isValidZipCode(postalCode);
- }
- return true;
- };
- var zipCodeValidator = new breeze.Validator("zipCodeValidator", valFn,
- { messageTemplate: "For the US, this is not a valid PostalCode" });
- var em1: breeze.EntityManager;
- var custType = em1.metadataStore.getEntityType("Customer");
- custType.validators.push(zipCodeValidator);
- var numericRangeValidator = function (context) {
- var valFn = function (v, ctx) {
- if (v == null) return true;
- if (typeof (v) !== "number") return false;
- if (ctx.min != null && v < ctx.min) return false;
- if (ctx.max != null && v > ctx.max) return false;
- return true;
- };
- return new breeze.Validator("numericRange", valFn, {
- messageTemplate: "'%displayName%' must be an integer between the values of %min% and %max%",
- min: context.min,
- max: context.max
- });
- };
- freightProperty.validators.push(numericRangeValidator({ min: 100, max: 500 }));
- var productType = em1.metadataStore.getEntityType("Product");
- var discontinuedProperty = productType.getProperty("Discontinued");
- discontinuedProperty.validators.push(breeze.Validator.bool());
- var orderType = em1.metadataStore.getEntityType("Order");
- var freightProperty = orderType.getProperty("Freight");
- regionProperty.validators.push(breeze.Validator.byte());
- var orderType = em1.metadataStore.getEntityType("Order");
- var orderDateProperty = orderType.getProperty("OrderDate");
- orderDateProperty.validators.push(breeze.Validator.date());
- var v0 = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
- v0.validate("adasdfasdf");
- var errMessage = v0.getMessage();
- var custType = em1.metadataStore.getEntityType("Customer");
- var customerIdProperty = custType.getProperty("CustomerID");
- customerIdProperty.validators.push(breeze.Validator.guid());
- var orderType = em1.metadataStore.getEntityType("Order");
- var freightProperty = orderType.getProperty("Freight");
- freightProperty.validators.push(breeze.Validator.int16());
- var orderType = em1.metadataStore.getEntityType("Order");
- var freightProperty = orderType.getProperty("Freight");
- freightProperty.validators.push(breeze.Validator.int32());
- var orderType = em1.metadataStore.getEntityType("Order");
- var freightProperty = orderType.getProperty("Freight");
- freightProperty.validators.push(breeze.Validator.int64());
- var custType = em1.metadataStore.getEntityType("Customer");
- var regionProperty = custType.getProperty("Region");
- regionProperty.validators.push(breeze.Validator.maxLength({ maxLength: 5 }));
- var orderType = em1.metadataStore.getEntityType("Order");
- var freightProperty = orderType.getProperty("Freight");
- freightProperty.validators.push(breeze.Validator.number());
- var custType = em1.metadataStore.getEntityType("Customer");
- var regionProperty = custType.getProperty("Region");
- regionProperty.validators.push(breeze.Validator.required());
- var custType = em1.metadataStore.getEntityType("Customer");
- var regionProperty = custType.getProperty("Region");
- regionProperty.validators.push(breeze.Validator.string());
- var custType = em1.metadataStore.getEntityType("Customer");
- var regionProperty = custType.getProperty("Region");
- regionProperty.validators.push(breeze.Validator.stringLength({ minLength: 2, maxLength: 5 }));
- var validator = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
- var result = validator.validate("asdf");
- var ok = result === null;
- result = validator.validate("adasdfasdf");
- var errMsg = result.errorMessage;
- var context = result.context;
- var sameValidator = result.validator;
- var valFn = function (v) {
- if (v == null) return true;
- return (v.substr(0,2) === "US");
- };
- var countryValidator = new breeze.Validator("countryIsUS", valFn, { displayName: "Country" });
- breeze.Validator.messageTemplates["countryIsUS"] = "'%displayName%' must start with 'US'";
-}
-
-function test_demo() {
-
- var manager = new breeze.EntityManager('api/northwind');
-
- var query = new breeze.EntityQuery()
- .from("Employees");
-
- manager.executeQuery(query).then(function (data) { });
-}
\ No newline at end of file
+// Type definitions for Breeze 1.4.1
+// Project: http://www.breezejs.com/
+// Definitions by: IdeaBlade
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///
+
+import core = breeze.core;
+import config = breeze.config;
+
+
+function test_dataType() {
+ var typ = breeze.DataType.DateTime;
+ var nm = typ.getName();
+ var dv = typ.defaultValue;
+ var symbs = breeze.DataType.getSymbols();
+ var x = typ.parentEnum === breeze.DataType;
+ var isFalse = breeze.DataType.contains(breeze.DataType.Double);
+ var dt = breeze.DataType.fromName("Decimal");
+
+}
+
+function test_dataProperty() {
+ var lastNameProp = new breeze.DataProperty({
+ name: "lastName",
+ dataType: breeze.DataType.String,
+ isNullable: true,
+ maxLength: 20
+ });
+ var personEntityType: breeze.EntityType;
+ personEntityType.addProperty(lastNameProp);
+}
+
+function test_dataService() {
+ var ds = new breeze.DataService({
+ serviceName: "breeze/NorthwindIBModel",
+ hasServerMetadata: true
+ });
+ var em = new breeze.EntityManager({
+ dataService: ds
+ });
+
+}
+
+function test_entityAspect() {
+ var order: breeze.Entity;
+ order.entityAspect.acceptChanges();
+ var entityKey = order.entityAspect.getKey();
+ var valErrors = order.entityAspect.getValidationErrors();
+ var orderDateErrors = order.entityAspect.getValidationErrors("OrderDate");
+ var orderDateProperty = order.entityType.getProperty("OrderDate");
+ var orderDateErrors = order.entityAspect.getValidationErrors(orderDateProperty);
+ order.entityAspect.loadNavigationProperty("Orders").then(function (data) {
+ var orders = data.results;
+ }).fail(function (exception) { });
+ order.entityAspect.rejectChanges();
+ order.entityAspect.setDeleted();
+ order.entityAspect.setModified();
+ order.entityAspect.setUnchanged();
+ var isOk = order.entityAspect.validateEntity();
+ if (!isOk) {
+ var errors = order.entityAspect.getValidationErrors();
+ }
+ var isOk = order.entityAspect.validateProperty("Order");
+ var orderDateProperty = order.entityType.getProperty("OrderDate");
+ //var isOk = order.entityAspect.validateProperty(OrderDateProperty);
+ order.entityAspect.propertyChanged.subscribe(function (propertyChangedArgs) {
+ var entity = propertyChangedArgs.entity;
+ var propertyNameChanged = propertyChangedArgs.propertyName;
+ var oldValue = propertyChangedArgs.oldValue;
+ var newValue = propertyChangedArgs.newValue;
+ });
+ order.entityAspect.validationErrorsChanged.subscribe(function (validationChangeArgs) {
+ var entity = validationChangeArgs.entity;
+ var errorsAdded = validationChangeArgs.added;
+ var errorsCleared = validationChangeArgs.removed;
+ });
+
+}
+
+function test_entityKey() {
+ var em1: breeze.EntityManager;
+ var employee1: breeze.Entity;
+ var empType = em1.metadataStore.getEntityType("Employee");
+ var entityKey = new breeze.EntityKey( empType, 1);
+ var empKey = employee1.entityAspect.getKey();
+ var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory");
+ var empTerrKey = new breeze.EntityKey( empTerrType, [1, 77]);
+ var empType = em1.metadataStore.getEntityType("Employee");
+ var empKey1 = new breeze.EntityKey( empType, 1);
+ var empKey2 = employee1.entityAspect.getKey();
+ if (empKey1.equals(empKey2)) { }
+ if (breeze.EntityKey.equals(empKey1, empKey2)) { }
+}
+
+function test_metadataStore() {
+ var ms = new breeze.MetadataStore();
+ var entityManager = new breeze.EntityManager({
+ serviceName: "breeze/NorthwindIBModel",
+ metadataStore: ms
+ });
+ var em1: breeze.EntityManager;
+ em1.setProperties({ metadataStore: ms });
+ var metadataAsString = ms.exportMetadata();
+ window.localStorage.setItem("metadata", metadataAsString);
+ var metadataFromStorage = window.localStorage.getItem("metadata");
+ var newMetadataStore = new breeze.MetadataStore();
+ newMetadataStore.importMetadata(metadataFromStorage);
+ var ms = new breeze.MetadataStore();
+ ms.fetchMetadata("breeze/NorthwindIBModel")
+ .then(function (rawMetadata) { })
+ .fail(function (exception) { });
+ var odType = em1.metadataStore.getEntityType("OrderDetail");
+ var badType = em1.metadataStore.getEntityType("Foo", false);
+ var allTypes = em1.metadataStore.getEntityTypes();
+ if (!em1.metadataStore.hasMetadataFor("breeze/NorthwindIBModel")) { }
+ var metadataAsString = ms.exportMetadata();
+ window.localStorage.setItem("metadata", metadataAsString);
+ var metadataFromStorage = window.localStorage.getItem("metadata");
+ var newMetadataStore = breeze.MetadataStore.importMetadata(metadataFromStorage);
+ var metadataAsString = ms.exportMetadata();
+ window.localStorage.setItem("metadata", metadataAsString);
+ var metadataFromStorage = window.localStorage.getItem("metadata");
+ var newMetadataStore = new breeze.MetadataStore();
+ newMetadataStore.importMetadata(metadataFromStorage);
+ if (em1.metadataStore.isEmpty()) { }
+ var Customer = function () {
+ this.miscData = "asdf";
+ }
+ em1.metadataStore.registerEntityTypeCtor("Customer", Customer);
+}
+
+function test_entityManager() {
+ var entityManager = new breeze.EntityManager("breeze/NorthwindIBModel");
+ var em1 = new breeze.EntityManager({ serviceName: "breeze/NorthwindIBModel" });
+ var metadataStore = new breeze.MetadataStore();
+ var entityManager = new breeze.EntityManager({
+ serviceName: "breeze/NorthwindIBModel",
+ metadataStore: metadataStore
+ });
+
+ return new breeze.QueryOptions({
+ mergeStrategy: null,
+ fetchStrategy: this.fetchStrategy
+ });
+ var queryOptions = new breeze.QueryOptions({
+ mergeStrategy: breeze.MergeStrategy.OverwriteChanges,
+ fetchStrategy: breeze.FetchStrategy.FromServer
+ });
+ var validationOptions = new breeze.ValidationOptions({
+ validateOnAttach: true,
+ validateOnSave: true,
+ validateOnQuery: false
+ });
+ var entityManager = new breeze.EntityManager({
+ serviceName: "breeze/NorthwindIBModel",
+ queryOptions: queryOptions,
+ validationOptions: validationOptions
+ });
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var cust1 = custType.createEntity();
+ em1.addEntity(cust1);
+
+ var cust2 = em1.createEntity("Customer", { companyName: "foo" });
+ var cust3 = em1.createEntity("foo", { xxx: 3 }, breeze.EntityState.Added);
+
+ em1.attachEntity(cust1, breeze.EntityState.Added);
+ em1.clear();
+ var em2 = em1.createEmptyCopy();
+ em1.detachEntity(cust1);
+ var serviceName: string;
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders");
+ em.executeQuery(query)
+ .then(function (data) {
+ var orders = data.results;
+ }).fail(function (err) {
+ });
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders");
+ em.executeQuery(query,
+ function (data) {
+ var orders = data.results;
+ },
+ function (err) {
+ });
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders").using(em);
+ query.execute()
+ .then(function (data) {
+ var orders = data.results;
+ }).fail(function (err) {
+ });
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders");
+ var orders = em.executeQueryLocally(query);
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders").using(breeze.FetchStrategy.FromLocalCache);
+ em.executeQuery(query)
+ .then(function (data) {
+ var orders = data.results;
+ }).fail(function (err) {
+ });
+ var bundle = em1.exportEntities();
+ window.localStorage.setItem("myEntityManager", bundle);
+ var bundleFromStorage = window.localStorage.getItem("myEntityManager");
+ var em2 = new breeze.EntityManager({
+ serviceName: em1.serviceName,
+ metadataStore: em1.metadataStore
+ });
+ em2.importEntities(bundleFromStorage);
+ var entitiesToExport: breeze.Entity[];
+ var bundle = em1.exportEntities(entitiesToExport);
+ em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges });
+ var em1 = new breeze.EntityManager("breeze/NorthwindIBModel");
+ em1.fetchMetadata()
+ .then(function () {
+ var metadataStore = em1.metadataStore;
+ })
+ .fail(function (exception) {
+ });
+ var employeeType = em1.metadataStore.getEntityType("Employee");
+ var employeeKey = new breeze.EntityKey( employeeType, 1);
+ var employee = em1.fetchEntityByKey(employeeKey);
+ var emp2 = em1.fetchEntityByKey("Employee", 6);
+ var emp3 = em1.fetchEntityByKey("Entityee", [6]);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var custumer = custType.createEntity();
+ var customerId = em.generateTempKeyValue(custumer);
+ em1.saveChanges()
+ .then(function (data) {
+ var sameCust1 = data.entities[0];
+ });
+ var changedEntities = em1.getChanges();
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var changedCustomers = em1.getChanges(custType);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var changedCustomersAndOrders = em1.getChanges([custType, orderType]);
+ var entities = em1.getEntities();
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var customers = em1.getEntities(custType);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var customersAndOrders = em1.getChanges([custType, orderType]);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var addedCustomersAndOrders = em1.getEntities([custType, orderType], breeze.EntityState.Added);
+ if (em1.hasChanges()) { }
+ var custType = em1.metadataStore.getEntityType("Customer");
+ if (em1.hasChanges(custType)) { }
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var orderType = em1.metadataStore.getEntityType("Order");
+ if (em1.hasChanges([custType, orderType])) { };
+
+ var bundle = em1.exportEntities();
+ window.localStorage.setItem("myEntityManager", bundle);
+ var bundleFromStorage = window.localStorage.getItem("myEntityManager");
+ var em2 = breeze.EntityManager.importEntities(bundleFromStorage);
+ var bundle = em1.exportEntities();
+ var em2 = new breeze.EntityManager({
+ serviceName: em1.serviceName,
+ metadataStore: em1.metadataStore
+ });
+ em2.importEntities(bundle);
+ var bundle = em1.exportEntities();
+ em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges });
+ em.saveChanges().then(function (saveResult) {
+ var savedEntities = saveResult.entities;
+ var keyMappings = saveResult.keyMappings;
+ }).fail(function (e) {
+ });
+ var saveOptions = new breeze.SaveOptions({ allowConcurrentSaves: true });
+ var entitiesToSave: breeze.Entity[];
+ em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult) {
+ var savedEntities = saveResult.entities;
+ var keyMappings = saveResult.keyMappings;
+ }).fail(function (e) {
+ });
+ em.saveChanges(entitiesToSave, null,
+ function (saveResult) {
+ var savedEntities = saveResult.entities;
+ var keyMappings = saveResult.keyMappings;
+ }, function (e) { }
+ );
+ em1.setProperties({
+ serviceName: "breeze/foo",
+ });
+ var em = new breeze.EntityManager({ serviceName: "breeze/NorthwindIBModel" });
+ em.entityChanged.subscribe(function (changeArgs) {
+ var action = changeArgs.entityAction;
+ var entity = changeArgs.entity;
+ });
+ var em = new breeze.EntityManager({ serviceName: "breeze/NorthwindIBModel" });
+ em.hasChangesChanged.subscribe(function (args) {
+ var hasChanges = args.hasChanges;
+ var entityManager = args.entityManager;
+ });
+}
+
+function test_entityQuery() {
+ var query = new breeze.EntityQuery("Customers");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .orderBy("Region");
+ var serviceName: string;
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders").using(em);
+ query.execute()
+ .then(function (data) { })
+ .fail(function (err) { });
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders").using(em);
+ query.execute(
+ function (data) {
+ var orders = data.results;
+ },
+ function (err) { });
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders");
+ em.executeQuery(query)
+ .then(function (data) {
+ var orders = data.results;
+ }).fail(function (err) {
+ });
+ var query = new breeze.EntityQuery("Orders").using(em);
+ var orders = query.executeLocally();
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .expand("Orders");
+ var query = new breeze.EntityQuery("Orders")
+ .expand("Customer, Employee");
+ var query = new breeze.EntityQuery("Orders")
+ .expand("Customer, OrderDetails, OrderDetails.Product");
+ var query = breeze.EntityQuery.from("Customers");
+ var query = new breeze.EntityQuery("Customers");
+ var query = new breeze.EntityQuery().from("Customers");
+ var customer: breeze.Entity;
+ var customers: breeze.Entity[];
+ var customersQuery = breeze.EntityQuery.fromEntities(customers);
+ var customersQuery = breeze.EntityQuery.fromEntities(customers)
+ .where("Region", breeze.FilterQueryOp.NotEquals, null);
+ var customerQuery = breeze.EntityQuery.fromEntities(customer);
+ var metadataStore: breeze.MetadataStore;
+ var empType = metadataStore.getEntityType("Employee");
+ var entityKey = new breeze.EntityKey( empType, 1);
+ var query = breeze.EntityQuery.fromEntityKey(entityKey);
+ var employee: breeze.Entity;
+ var entityKey = employee.entityAspect.getKey();
+ var query = breeze.EntityQuery.fromEntityKey(entityKey);
+ var ordersNavProp = employee.entityType.getProperty("Orders");
+ var query = breeze.EntityQuery.fromEntityNavigation(employee, ordersNavProp);
+ var query = new breeze.EntityQuery("Customers")
+ .orderBy("CompanyName");
+ var query = new breeze.EntityQuery("Customers")
+ .orderBy("Region, CompanyName");
+ var query = new breeze.EntityQuery("Products")
+ .orderBy("Category.CategoryName");
+ var query = new breeze.EntityQuery("Customers")
+ .orderBy("CompanyName desc");
+ var query = new breeze.EntityQuery("Customers")
+ .orderBy("Region desc, CompanyName desc");
+ var query = new breeze.EntityQuery("Customers")
+ .orderByDesc("CompanyName");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .select("CompanyName");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .select("Orders");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .select("CompanyName, Orders");
+ var query = new breeze.EntityQuery("Orders")
+ .where("Customer.CompanyName", "startsWith", "C")
+ .select("Customer.CompanyName, Customer, OrderDate");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C")
+ .skip(5);
+ var query = new breeze.EntityQuery("Customers")
+ .take(5);
+ var query = new breeze.EntityQuery("Customers")
+ .top(5);
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders")
+ .using(em);
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders")
+ .using(breeze.MergeStrategy.PreserveChanges);
+ var em = new breeze.EntityManager(serviceName);
+ var query = new breeze.EntityQuery("Orders")
+ .using(breeze.FetchStrategy.FromLocalCache);
+ var adapter = new breeze.JsonResultsAdapter({ name: "foo", visitNode: function (x) { return x; } });
+ var q2 = query.using(adapter);
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", "startsWith", "C");
+ var query = new breeze.EntityQuery("Customers")
+ .where("CompanyName", breeze.FilterQueryOp.StartsWith, "C");
+ var pred = new breeze.Predicate("CompanyName", breeze.FilterQueryOp.StartsWith, "C");
+ var query = new breeze.EntityQuery("Customers")
+ .where(pred);
+ var pred = breeze.Predicate.create("CompanyName", "startswith", "C").and("Region", breeze.FilterQueryOp.Equals, null);
+ var query = new breeze.EntityQuery("Customers")
+ .where(pred);
+ var query = new breeze.EntityQuery("Products")
+ .where("Category.CategoryName", "startswith", "S");
+ var query = new breeze.EntityQuery("Customers")
+ .where("toLower(CompanyName)", "startsWith", "c");
+ var query = new breeze.EntityQuery("Customers")
+ .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM");
+ var q2 = query.toType("foo").orderBy("foo2");
+}
+
+function test_entityState() {
+ var anEntity: breeze.Entity;
+ var es = anEntity.entityAspect.entityState;
+ return es.isAdded();
+ return es === breeze.EntityState.Added;
+ var es = anEntity.entityAspect.entityState;
+ return es.isAddedModifiedOrDeleted();
+ return es === breeze.EntityState.Added || es === breeze.EntityState.Modified || es === breeze.EntityState.Deleted;
+ var es = anEntity.entityAspect.entityState;
+ return es.isDeleted();
+ return es === breeze.EntityState.Deleted;
+ var es = anEntity.entityAspect.entityState;
+ return es.isDetached();
+ return es === breeze.EntityState.Detached;
+ var es = anEntity.entityAspect.entityState;
+ return es.isModified();
+ return es === breeze.EntityState.Modified;
+ var es = anEntity.entityAspect.entityState;
+ return es.isUnchanged();
+ return es === breeze.EntityState.Unchanged;
+ var es = anEntity.entityAspect.entityState;
+ return es.isUnchangedOrModified();
+
+ return es === breeze.EntityState.Unchanged || es === breeze.EntityState.Modified;
+}
+
+function test_entityType() {
+ var myMetadataStore: breeze.MetadataStore;
+ var myEntityType: breeze.EntityType;
+ var dataProperty1, dataProperty2, navigationProperty1: breeze.DataProperty;
+ var em1: breeze.EntityManager;
+ var entityManager = new breeze.EntityType({
+ metadataStore: myMetadataStore,
+ serviceName: "breeze/NorthwindIBModel",
+ name: "person",
+ namespace: "myAppNamespace"
+ });
+ myEntityType.addProperty(dataProperty1);
+ myEntityType.addProperty(dataProperty2);
+ myEntityType.addProperty(navigationProperty1);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var countryProp = custType.getProperty("Country");
+ var valFn = function (v) {
+ if (v == null) return true;
+ return (v.substring(0,2) === "US");
+ };
+ var countryValidator = new breeze.Validator("countryIsUS", valFn,
+ { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" });
+ custType.addValidator(countryValidator, countryProp);
+ countryProp.validators.push(countryValidator);
+ var someEntityLevelValidator: breeze.Validator;
+ custType.addValidator(someEntityLevelValidator);
+ custType.validators.push(someEntityLevelValidator);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var cust1 = custType.createEntity();
+ em1.addEntity(cust1);
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var customerNameDataProp = custType.getDataProperty("CustomerName");
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var customerOrdersNavProp = custType.getDataProperty("Orders");
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var arrayOfProps = custType.getProperties();
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var companyNameProp = custType.getProperty("CompanyName");
+ var orderDetailType = em1.metadataStore.getEntityType("OrderDetail");
+ var companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName");
+ var custType = em1.metadataStore.getEntityType("Customer");
+ var arrayOfPropNames = custType.getPropertyNames();
+ var custType = em1.metadataStore.getEntityType("Customer");
+ custType.setProperties({
+ autoGeneratedKeyType: breeze.AutoGeneratedKeyType.Identity,
+ defaultResourceName: "CustomersAndIncludedOrders"
+ });
+}
+
+//function test_enum() {
+// var prototype = {
+// nextDay: function () {
+// var nextIndex = (this.dayIndex + 1) % 7;
+// return DayOfWeek.getSymbols()[nextIndex];
+// }
+// };
+// var DayOfWeek = new core.Enum("DayOfWeek", prototype);
+// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 });
+// var symbol = DayOfWeek.Friday;
+// if (DayOfWeek.contains(symbol)) { }
+// var dayOfWeek = DayOfWeek.from("Thursday");
+// var symbols = DayOfWeek.getNames();
+// var symbols = DayOfWeek.getSymbols();
+// if (core.Enum.isSymbol(DayOfWeek.Wednesday)) { };
+// DayOfWeek.seal();
+// var name = DayOfWeek.Monday.getName();
+// var name = DayOfWeek.Monday.toString();
+
+
+// var prototype = {
+// nextDay: function () {
+// var nextIndex = (this.dayIndex + 1) % 7;
+// return DayOfWeek.getSymbols()[nextIndex];
+// }
+// };
+// var DayOfWeek = new core.Enum("DayOfWeek", prototype);
+// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 });
+// DayOfWeek.Tuesday = DayOfWeek.addSymbol({ dayIndex: 1 });
+// DayOfWeek.Wednesday = DayOfWeek.addSymbol({ dayIndex: 2 });
+// DayOfWeek.Thursday = DayOfWeek.addSymbol({ dayIndex: 3 });
+// DayOfWeek.Friday = DayOfWeek.addSymbol({ dayIndex: 4 });
+// DayOfWeek.Saturday = DayOfWeek.addSymbol({ dayIndex: 5, isWeekend: true });
+// DayOfWeek.Sunday = DayOfWeek.addSymbol({ dayIndex: 6, isWeekend: true });
+// DayOfWeek.seal();
+// DayOfWeek.Monday.nextDay() === DayOfWeek.Tuesday;
+// DayOfWeek.Sunday.nextDay() === DayOfWeek.Monday;
+// DayOfWeek.Tuesday.isWeekend === undefined;
+// DayOfWeek.Saturday.isWeekend == true;
+// DayOfWeek instanceof core.Enum;
+// core.Enum.isSymbol(DayOfWeek.Wednesday);
+// DayOfWeek.contains(DayOfWeek.Thursday);
+// DayOfWeek.Tuesday.parentEnum == DayOfWeek;
+// DayOfWeek.getSymbols().length === 7;
+// DayOfWeek.Friday.toString() === "Friday";
+//}
+
+function test_event() {
+ var myEntityManager: breeze.EntityManager;
+ var myEntity, person: breeze.Entity;
+ var salaryEvent = new core.Event("salaryEvent", person);
+ core.Event.enable("propertyChanged", myEntityManager, false);
+ core.Event.enable("propertyChanged", myEntityManager, true);
+ core.Event.enable("propertyChanged", myEntity.entityAspect, false);
+ core.Event.enable("propertyChanged", myEntity.entityAspect, null);
+ core.Event.enable("validationErrorsChanged", myEntityManager, function (em) {
+ return em.customTag === "blue";
+ });
+ core.Event.isEnabled("propertyChanged", myEntityManager);
+ salaryEvent.publish({ eventType: "payRaise", amount: 100 });
+ salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true);
+ salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true, function (error) { });
+ salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 });
+ salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 }, function (error) { });
+ salaryEvent.subscribe(function (eventArgs) {
+ if (eventArgs.eventType === "payRaise") { }
+ });
+ var order: breeze.Entity;
+ order.entityAspect.propertyChanged.subscribe(function (pcEvent) {
+ if (pcEvent.propertyName === "OrderDate") { }
+ });
+ var token = order.entityAspect.propertyChanged.subscribe(function (pcEvent) { });
+ order.entityAspect.propertyChanged.unsubscribe(token);
+}
+
+function test_localQueryComparisonOptions() {
+ var lqco = new breeze.LocalQueryComparisonOptions({
+ name: "caseSensitive-nonSQL",
+ isCaseSensitive: true,
+ usesSql92CompliantStringComparison: false
+ });
+ lqco.setAsDefault();
+ var ms = new breeze.MetadataStore({ localQueryComparisonOptions: lqco });
+ var em = new breeze.EntityManager({ metadataStore: ms });
+ var lqco = new breeze.LocalQueryComparisonOptions({
+ isCaseSensitive: false,
+ usesSql92CompliantStringComparison: true
+ });
+ lqco.setAsDefault();
+}
+
+function test_namingConventions() {
+ var namingConv = new breeze.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 nc = new breeze.NamingConvention({
+ serverPropertyNameToClient: function (x) {
+ return "xxx";
+ }
+ });
+ var ms = new breeze.MetadataStore({ namingConvention: namingConv });
+ var em = new breeze.EntityManager({ metadataStore: ms });
+ var namingConv = new breeze.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();
+}
+
+function test_navigationProperty() {
+ var homeAddressProp = new breeze.NavigationProperty({
+ name: "homeAddress",
+ entityTypeName: "Address:#myNamespace",
+ isScalar: true,
+ associationName: "address_person",
+ foreignKeyNames: ["homeAddressId"]
+ });
+ var homeAddressIdProp = new breeze.DataProperty({
+ name: "homeAddressId",
+ dataType: breeze.DataType.Int32
+ });
+ var personEntityType: breeze.EntityType;
+ personEntityType.addProperty(homeAddressProp);
+ personEntityType.addProperty(homeAddressIdProp);
+}
+
+function test_predicate() {
+ var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B");
+ var p1a = breeze.Predicate.create("CompanyName", "==", "City");
+ var p2a = p1a.and(p1a.not());
+ var query = new breeze.EntityQuery("Customers").where(p1);
+ var p2 = new breeze.Predicate("Region", breeze.FilterQueryOp.Equals, null);
+ var query = new breeze.EntityQuery("Customers").where(p2);
+ var dt = new Date(88, 9, 12);
+ var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+ var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+ var p3 = breeze.Predicate.create("Freight", ">", 100);
+ var newPred = p1.and(p2, p3);
+ var preds = [p2, p3];
+ var newPred = p1.and(preds);
+ var p4 = breeze.Predicate.create("ShipCity", "startswith", "F")
+ .and("Size", "gt", 2000);
+ var dt = new Date(88, 9, 12);
+ var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+ var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+ var p3 = breeze.Predicate.create("Freight", ">", 100);
+ var newPred = breeze.Predicate.and(p1, p2, p3);
+ var preds = [p1, p2, p3];
+ var newPred = breeze.Predicate.and(preds);
+ var p1 = breeze.Predicate.create("Freight", "gt", 100);
+ var predArgs: any[] = ["Freight", "gt", 100];
+ var p1 = breeze.Predicate.create(predArgs);
+ var p1 = new breeze.Predicate("Freight", "gt", 100);
+ var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B");
+ if (breeze.Predicate.isPredicate(p1)) { }
+ var p1 = breeze.Predicate.create("Freight", "gt", 100);
+ var not_p1 = breeze.Predicate.not(p1);
+ var not_p1 = p1.not();
+ var not_p1 = breeze.Predicate.create("Freight", "le", 100);
+ var dt = new Date(88, 9, 12);
+ var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+ var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+ var p3 = breeze.Predicate.create("Freight", ">", 100);
+ var newPred = breeze.Predicate.or(p1, p2, p3);
+ var preds = [p1, p2, p3];
+ var newPred = breeze.Predicate.or(preds);
+ var dt = new Date(88, 9, 12);
+ var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+ var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+ var p3 = breeze.Predicate.create("Freight", ">", 100);
+ var newPred = p1.and(p2, p3);
+ var preds = [p2, p3];
+ var newPred = p1.and(preds);
+ var p4 = breeze.Predicate.create("ShipCity", "startswith", "F")
+ .or("Size", "gt", 2000);
+}
+
+function test_queryOptions() {
+ var em1: breeze.EntityManager;
+ var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
+ em1.setProperties({ queryOptions: newQo });
+ var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
+ newQo.setAsDefault();
+ var queryOptions = em1.queryOptions.using(breeze.MergeStrategy.PreserveChanges);
+ var queryOptions = em1.queryOptions.using(breeze.FetchStrategy.FromLocalCache);
+ var queryOptions = em1.queryOptions.using({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
+}
+
+function test_validationOptions() {
+ var newVo = new breeze.ValidationOptions({ validateOnSave: false, validateOnAttach: false });
+ var em1: breeze.EntityManager;
+ em1.setProperties({ validationOptions: newVo });
+ var validationOptions = new breeze.ValidationOptions()
+ var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
+ newOptions.setAsDefault();
+ var validationOptions = new breeze.ValidationOptions();
+ var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
+}
+
+function test_validator() {
+ var valFn = function (v) {
+ if (v == null) return true;
+ return ( v.substr(0,2)=== "US");
+ };
+ var countryValidator = new breeze.Validator("countryIsUS", valFn, {
+ displayName: "Country",
+ messageTemplate: "'%displayName%' must start with 'US'"
+ });
+ var metadataStore: breeze.MetadataStore;
+ var custType = metadataStore.getEntityType("Customer");
+ var countryProp = custType.getProperty("Country");
+ countryProp.validators.push(countryValidator);
+ function isValidZipCode(value) {
+ var re = /^\d{5}([\-]\d{4})?$/;
+ return (re.test(value));
+ }
+ var valFn = function (v) {
+ if (v.getProperty("Country") === "USA") {
+ var postalCode = v.getProperty("PostalCode");
+ return isValidZipCode(postalCode);
+ }
+ return true;
+ };
+ var zipCodeValidator = new breeze.Validator("zipCodeValidator", valFn,
+ { messageTemplate: "For the US, this is not a valid PostalCode" });
+ var em1: breeze.EntityManager;
+ var custType = em1.metadataStore.getEntityType("Customer");
+ custType.validators.push(zipCodeValidator);
+ var numericRangeValidator = function (context) {
+ var valFn = function (v, ctx) {
+ if (v == null) return true;
+ if (typeof (v) !== "number") return false;
+ if (ctx.min != null && v < ctx.min) return false;
+ if (ctx.max != null && v > ctx.max) return false;
+ return true;
+ };
+ return new breeze.Validator("numericRange", valFn, {
+ messageTemplate: "'%displayName%' must be an integer between the values of %min% and %max%",
+ min: context.min,
+ max: context.max
+ });
+ };
+ freightProperty.validators.push(numericRangeValidator({ min: 100, max: 500 }));
+ var productType = em1.metadataStore.getEntityType("Product");
+ var discontinuedProperty = productType.getProperty("Discontinued");
+ discontinuedProperty.validators.push(breeze.Validator.bool());
+ var orderType = em1.metadataStore.getEntityType("Order");
+ var freightProperty = orderType.getProperty("Freight");
+ regionProperty.validators.push(breeze.Validator.byte());
+ orderType = em1.metadataStore.getEntityType("Order");
+ var orderDateProperty = orderType.getProperty("OrderDate");
+ orderDateProperty.validators.push(breeze.Validator.date());
+ var v0 = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
+ v0.validate("adasdfasdf");
+ var errMessage = v0.getMessage();
+ custType = em1.metadataStore.getEntityType("Customer");
+ var customerIdProperty = custType.getProperty("CustomerID");
+ customerIdProperty.validators.push(breeze.Validator.guid());
+ orderType = em1.metadataStore.getEntityType("Order");
+ freightProperty = orderType.getProperty("Freight");
+ freightProperty.validators.push(breeze.Validator.int16());
+ orderType = em1.metadataStore.getEntityType("Order");
+ freightProperty = orderType.getProperty("Freight");
+ freightProperty.validators.push(breeze.Validator.int32());
+ orderType = em1.metadataStore.getEntityType("Order");
+ freightProperty = orderType.getProperty("Freight");
+ freightProperty.validators.push(breeze.Validator.int64());
+ custType = em1.metadataStore.getEntityType("Customer");
+ var regionProperty = custType.getProperty("Region");
+ regionProperty.validators.push(breeze.Validator.maxLength({ maxLength: 5 }));
+ orderType = em1.metadataStore.getEntityType("Order");
+ freightProperty = orderType.getProperty("Freight");
+ freightProperty.validators.push(breeze.Validator.number());
+ custType = em1.metadataStore.getEntityType("Customer");
+ regionProperty = custType.getProperty("Region");
+ regionProperty.validators.push(breeze.Validator.required());
+ custType = em1.metadataStore.getEntityType("Customer");
+ regionProperty = custType.getProperty("Region");
+ regionProperty.validators.push(breeze.Validator.string());
+ custType = em1.metadataStore.getEntityType("Customer");
+ regionProperty = custType.getProperty("Region");
+ regionProperty.validators.push(breeze.Validator.stringLength({ minLength: 2, maxLength: 5 }));
+ var validator = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
+ var result = validator.validate("asdf");
+ var ok = result === null;
+ result = validator.validate("adasdfasdf");
+ var errMsg = result.errorMessage;
+ var context = result.context;
+ var sameValidator = result.validator;
+ var valFn = function (v) {
+ if (v == null) return true;
+ return (v.substr(0,2) === "US");
+ };
+ var countryValidator = new breeze.Validator("countryIsUS", valFn, { displayName: "Country" });
+ breeze.Validator.messageTemplates["countryIsUS"] = "'%displayName%' must start with 'US'";
+
+ breeze.Validator.register(countryValidator);
+ breeze.Validator.registerFactory(() => countryValidator, "country");
+}
+
+function test_demo() {
+
+ var manager = new breeze.EntityManager('breeze/northwind');
+
+ var query = new breeze.EntityQuery()
+ .from("Employees");
+
+ manager.executeQuery(query).then(function (data) { });
+}
+
+function test_corefns() {
+ var o1: Object;
+ var kvfn = function (p) { return p; }
+ core.objectForEach(o1, kvfn);
+
+ var o2: Object;
+ var o3: Object;
+ o3 = core.extend(o1, o2);
+
+ var f1: Function;
+ var f2: Function;
+ f1 = core.propEq("name", "Joe");
+ f1 = core.pluck("name");
+
+ var a1: Array;
+ var a2: Array;
+ var a3: Array;
+ var b: boolean;
+ var n: number;
+
+ var f3 = function (e1: any, e2: any) { return e1 == e2; };
+ var f4 = function (e1: any) { return false; };
+ b = core.arrayEquals(a1, a2, f3);
+ b = core.arrayFirst(a1, f4);
+ n = core.arrayIndexOf(a1, f4);
+ b = core.arrayRemoveItem(a1, "whatever", false);
+ a3 = core.arrayZip(a1, a2, f3);
+
+ var f5 = function () { return false; };
+ o1 = core.requireLib("libc,stdio", "Library not found");
+ o1 = core.using(o2, "something", "x", f5);
+ f2 = core.memoize(f4);
+ var s: string;
+ s = core.getUuid();
+ n = core.durationToSeconds(s);
+
+ b = core.isDate(s);
+ b = core.isGuid(s);
+ b = core.isDuration(s);
+ b = core.isFunction(s);
+ b = core.isEmpty(s);
+ b = core.isNumeric(s);
+
+ b = core.stringStartsWith(s, "pre");
+ b = core.stringEndsWith(s, "suf");
+ s = core.formatString("My %1 is full of %2", "hovercraft", "eels");
+
+}
+
+function test_config() {
+ var s: string;
+ s = config.ajax;
+ s = config.dataService;
+ var o: Object;
+ o = config.functionRegistry;
+ o = config.getAdapter("myInterfaceName", "myAdapterName");
+ o = config.getAdapterInstance("myInterfaceName", "myAdapterName");
+ config.initializeAdapterInstance("myInterfaceName", "myAdapterName", true);
+ config.initializeAdapterInstances({ x: 3, y: "not" });
+ s = config.interfaceInitialized.type;
+ o = config.interfaceRegistry;
+ o = config.objectRegistry;
+ config.registerAdapter("myAdapterName");
+ var f1: Function;
+ config.registerFunction(f1, "myFunction");
+ config.registerType(f1, "myCtor");
+ s = config.stringifyPad;
+ o = config.typeRegistry;
+}
diff --git a/breeze/breeze.d.ts b/breeze/breeze.d.ts
index cb0aa13f9..090490cb5 100644
--- a/breeze/breeze.d.ts
+++ b/breeze/breeze.d.ts
@@ -1,779 +1,899 @@
-// Type definitions for Breeze 1.2.7
-// Project: http://www.breezejs.com/
-// Definitions by: Boris Yankov ,
-// IdeaBlade
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-// Updated March 27 2013 - John Lantz (www.ideablade.com)
-
-
-declare module breezeCore {
-
- interface ErrorCallback {
- (error: Error): void;
- }
-
- interface IEnum {
- contains(object: any): boolean;
- fromName(name: string): EnumSymbol;
- getNames(): string[];
- getSymbols(): EnumSymbol[];
- }
-
- class Enum implements IEnum {
- constructor (name: string, methodObj?: any);
-
- addSymbol(propertiesObj?: any): EnumSymbol;
- contains(object: any): boolean;
- fromName(name: string): EnumSymbol;
- getNames(): string[];
- getSymbols(): EnumSymbol[];
- static isSymbol(object: any): boolean;
- seal(): void;
- }
-
- class EnumSymbol {
- parentEnum: IEnum;
-
- getName(): string;
- toString(): string;
- }
-
- class Event {
- constructor (name: string, publisher: any, defaultErrorCallback?: ErrorCallback);
-
- static enable(eventName: string, target: any): void;
- static enable(eventName: string, target: any, isEnabled: boolean): void;
- static enable(eventName: string, target: any, isEnabled: Function): void;
-
- static isEnabled(eventName: string, target: any): boolean;
- publish(data: any, publishAsync?: boolean, errorCallback?: ErrorCallback): void;
- publishAsync(data: any, errorCallback?: ErrorCallback): void;
- subscribe(callback?: (data: any) => void ): number;
- unsubscribe(unsubKey: number): boolean;
- }
-}
-
-declare module breeze {
-
- interface Entity {
- entityAspect: EntityAspect;
- entityType: EntityType;
- }
-
- interface ComplexObject {
- complexAspect: ComplexAspect;
- complexType: ComplexType;
- }
-
- interface IProperty {
- name: string;
- parentEntityType: EntityType;
- validators: Validator[];
- isDataProperty: boolean;
- isNavigationProperty: boolean;
- }
-
- interface IStructuralType {
- complexProperties: DataProperty[];
- dataProperties: DataProperty[];
- name: string;
- namespace: string;
- shortName: string;
- unmappedProperties: DataProperty[];
- validators: Validator[];
- }
-
- class AutoGeneratedKeyType {
- static Identity: AutoGeneratedKeyType;
- static KeyGenerator: AutoGeneratedKeyType;
- static None: AutoGeneratedKeyType;
- }
-
- class ComplexAspect {
- complexObject: ComplexObject;
- entityAspect: EntityAspect;
- parent: Object;
- parentProperty: DataProperty;
- propertyPath: string;
- originalValues: Object;
- }
-
- class ComplexType implements IStructuralType {
- complexProperties: DataProperty[];
- dataProperties: DataProperty[];
- name: string;
- namespace: string;
- shortName: string;
- unmappedProperties: DataProperty[];
- validators: Validator[];
- addProperty(dataProperty: DataProperty);
- getProperties(): DataProperty[];
- }
-
- class DataProperty implements IProperty {
- complexTypeName: string;
- concurrencyMode: string;
- dataType: DataTypeSymbol;
- defaultValue: any;
- fixedLength: boolean;
- isComplexProperty: boolean;
- isDataProperty: boolean;
- isNavigationProperty: boolean;
- isNullable: boolean;
- isPartOfKey: boolean;
- isUnmapped: boolean;
-
- maxLength: number;
- name: string;
- nameOnServer: string;
- parentEntityType: EntityType;
- relatedNavigationProperty: NavigationProperty;
- validators: Validator[];
- constructor (config: DataPropertyOptions);
- }
-
- interface DataPropertyOptions {
- complexTypeName?: string;
- concurrencyMode?: string;
- dataType?: DataTypeSymbol;
- defaultValue?: any;
- fixedLength?: boolean;
- isNullable?: boolean;
- isPartOfKey?: boolean;
- isUnmapped?: boolean;
- maxLength?: number;
- name?: string;
- nameOnServer?: string;
- validators?: Validator[];
- }
-
- class DataService {
- adapterName: string;
- hasServerMetadata: boolean;
- serviceName: string;
- jsonResultsAdapter: JsonResultsAdapter;
- constructor(config: DataServiceOptions);
- }
-
- interface DataServiceOptions {
- adapterName?: string;
- hasServerMetadata?: boolean;
- serviceName?: string;
- jsonResultsAdapter?: JsonResultsAdapter;
- }
-
- class JsonResultsAdapter {
- name: string;
- extractResults: (data: {}) => {};
- visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: boolean; };
- constructor(config: {
- name: string;
- extractResults?: (data: {}) => {};
- visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: boolean; };
- });
- }
-
- interface QueryContext {
- query: any; // how to also say it could be an EntityQuery or a string
- entityManager: EntityManager;
- jsonResultsAdapter: JsonResultsAdapter;
- mergeStrategy: MergeStrategy;
- }
-
- interface NodeContext {
- nodeType: string;
- }
-
-
-
- class DataTypeSymbol extends breezeCore.EnumSymbol {
- defaultValue: any;
- isNumeric: boolean;
- }
- interface DataType extends breezeCore.IEnum {
- Binary: DataTypeSymbol;
- Boolean: DataTypeSymbol;
- Byte: DataTypeSymbol;
- DateTime: DataTypeSymbol;
- Decimal: DataTypeSymbol;
- Double: DataTypeSymbol;
- Guid: DataTypeSymbol;
- Int16: DataTypeSymbol;
- Int32: DataTypeSymbol;
- Int64: DataTypeSymbol;
- Single: DataTypeSymbol;
- String: DataTypeSymbol;
- Time: DataTypeSymbol;
- Undefined: DataTypeSymbol;
- toDataType(typeName: string): DataTypeSymbol;
- parseDateFromServer(date: any): Date;
-
- }
- var DataType: DataType;
-
- class EntityActionSymbol extends breezeCore.EnumSymbol {
- }
- interface EntityAction extends breezeCore.IEnum {
- AcceptChanges: EntityActionSymbol;
- Attach: EntityActionSymbol;
- AttachOnImport: EntityActionSymbol;
- AttachOnQuery: EntityActionSymbol;
- Clear: EntityActionSymbol;
- Detach: EntityActionSymbol;
- EntityStateChange: EntityActionSymbol;
- MergeOnImport: EntityActionSymbol;
- MergeOnSave: EntityActionSymbol;
- MergeOnQuery: EntityActionSymbol;
- PropertyChange: EntityActionSymbol;
- RejectChanges: EntityActionSymbol;
- }
- var EntityAction: EntityAction;
-
- class EntityAspect {
- entity: Entity;
- entityManager: EntityManager;
- entityState: EntityStateSymbol;
- isBeingSaved: boolean;
- originalValues: any;
-
- propertyChanged: PropertyChangedEvent;
- validationErrorsChanged: ValidationErrorsChangedEvent;
-
- acceptChanges(): void;
- addValidationError(validationError: ValidationError): void;
- clearValidationErrors(): void;
- getKey(forceRefresh?: boolean): EntityKey;
-
- getValidationErrors(): ValidationError[];
- getValidationErrors(property: string): ValidationError[];
- getValidationErrors(property: IProperty): ValidationError[];
-
- loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): Promise;
- loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): Promise;
-
- rejectChanges(): void;
-
- removeValidationError(validator: Validator): void;
- removeValidationError(validator: Validator, property: DataProperty): void;
- removeValidationError(validator: Validator, property: NavigationProperty): void;
-
- setDeleted(): void;
- setModified(): void;
- setUnchanged(): void;
- setDetached(): boolean;
- validateEntity(): boolean;
-
- validateProperty(property: string, context?: any): boolean;
- validateProperty(property: DataProperty, context?: any): boolean;
- validateProperty(property: NavigationProperty, context?: any): boolean;
- }
-
- class PropertyChangedEventArgs {
- entity: Entity;
- propertyName: string;
- oldValue: any;
- newValue: any;
- }
-
- class PropertyChangedEvent extends breezeCore.Event {
- subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number;
- }
-
- class ValidationErrorsChangedEventArgs {
- entity: Entity;
- added: ValidationError[];
- removed: ValidationError[];
- }
-
- class ValidationErrorsChangedEvent extends breezeCore.Event {
- subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number;
- }
-
- class EntityKey {
- constructor (entityType: EntityType, keyValue: any);
- constructor (entityType: EntityType, keyValues: any[]);
-
- equals(entityKey: EntityKey): boolean;
- static equals(k1: EntityKey, k2: EntityKey): boolean;
- }
-
- class EntityManager {
- dataService: DataService;
- keyGeneratorCtor: Function;
- metadataStore: MetadataStore;
- queryOptions: QueryOptions;
- saveOptions: SaveOptions;
- serviceName: string;
- validationOptions: ValidationOptions;
-
- entityChanged: EntityChangedEvent;
- hasChangesChanged: HasChangesChangedEvent;
-
- constructor (config?: EntityManagerOptions);
- constructor (config?: string);
-
- addEntity(entity: Entity): Entity;
- attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity;
- clear(): void;
- createEmptyCopy(): EntityManager;
- createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol) : Entity;
- detachEntity(entity: Entity): boolean;
- executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
- executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
-
- executeQueryLocally(query: EntityQuery): Entity[];
- exportEntities(entities?: Entity[]): string;
- fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: boolean): Promise;
- fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: boolean): Promise;
- fetchEntityByKey(entityKey: EntityKey): Promise;
- fetchMetadata(callback?: (schema: any) => void , errorCallback?: breezeCore.ErrorCallback): Promise;
- generateTempKeyValue(entity: Entity): any;
- getChanges(): Entity[];
- getChanges(entityTypeName: string): Entity[];
- getChanges(entityTypeNames: string[]): Entity[];
- getChanges(entityType: EntityType): Entity[];
- getChanges(entityTypes: EntityType[]): Entity[];
-
- getEntities(entityTypeName: string, entityState?: EntityStateSymbol): Entity[];
- getEntities(entityTypeNames?: string[], entityState?: EntityStateSymbol): Entity[];
- getEntities(entityTypeName?: string, entityStates?: EntityStateSymbol[]): Entity[];
- getEntities(entityTypeNames?: string[], entityStates?: EntityStateSymbol[]): Entity[];
-
- getEntities(entityType: EntityType, entityState?: EntityStateSymbol): Entity[];
- getEntities(entityTypes?: EntityType[], entityState?: EntityStateSymbol): Entity[];
- getEntities(entityType?: EntityType, entityStates?: EntityStateSymbol[]): Entity[];
- getEntities(entityTypes?: EntityType[], entityStates?: EntityStateSymbol[]): Entity[];
-
- getEntityByKey(typeName: string, keyValue: any): Entity;
- getEntityByKey(typeName: string, keyValues: any[]): Entity;
- getEntityByKey(entityKey: EntityKey): Entity;
-
- hasChanges(): boolean;
- hasChanges(entityTypeName: string): boolean;
- hasChanges(entityTypeNames: string[]): boolean;
- hasChanges(entityType: EntityType): boolean;
- hasChanges(entityTypes: EntityType[]): boolean;
-
- static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
- importEntities(exportedString: any, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
-
- rejectChanges(): Entity[];
- saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Promise;
- setProperties(config: EntityManagerProperties): void;
-
- helper: {
- unwrapInstance(structObj: Entity, isOData: boolean): any;
- unwrapOriginalValues(target: Entity, metadataStore: MetadataStore, isOData: boolean): any;
- unwrapChangedValues(target: Entity, metadataStore: MetadataStore, isOData: boolean): any;
- getEntityKeyFromRawEntity(rawEntity: any, entityType: EntityType, isClient: boolean): EntityKey;
- };
- }
-
- interface EntityManagerOptions {
- serviceName?: string;
- dataService?: DataService;
- metadataStore?: MetadataStore;
- queryOptions?: QueryOptions;
- saveOptions?: SaveOptions;
- validationOptions?: ValidationOptions;
- keyGeneratorCtor?: Function;
- }
-
- interface EntityManagerProperties {
- serviceName?: string;
- dataService?: DataService;
- queryOptions?: QueryOptions;
- saveOptions?: SaveOptions;
- validationOptions?: ValidationOptions;
- keyGeneratorCtor?: Function;
- }
-
- interface ExecuteQuerySuccessCallback {
- (data: { results: Entity[]; query: EntityQuery; XHR: XMLHttpRequest; }): void;
- }
-
- interface ExecuteQueryErrorCallback {
- (error: { query: EntityQuery; XHR: XMLHttpRequest; }): void;
- }
-
- interface SaveChangesSuccessCallback {
- (saveResult: { entities: Entity[]; keyMappings: any; XHR: XMLHttpRequest; }): void;
- }
-
- interface SaveChangesErrorCallback {
- (error: { XHR: XMLHttpRequest; }): void;
- }
-
- class EntityChangedEventArgs {
- entity: Entity;
- entityAction: EntityActionSymbol;
- args: Object;
- }
-
- class EntityChangedEvent extends breezeCore.Event {
- subscribe(callback?: (data: EntityChangedEventArgs) => void ): number;
- }
-
- class HasChangesChangedEventArgs {
- entityManager: EntityManager;
- hasChanges: boolean;
- }
-
- class HasChangesChangedEvent extends breezeCore.Event {
- subscribe(callback?: (data: HasChangesChangedEventArgs) => void ): number;
- }
-
- class EntityQuery {
- entityManager: EntityManager;
- orderByClause: OrderByClause;
- parameters: Object;
- queryOptions: QueryOptions;
- resourceName: string;
- skipCount: number;
- takeCount: number;
- wherePredicate: Predicate;
-
- constructor (resourceName?: string);
-
- execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
- executeLocally(): Entity[];
- expand(propertyPaths: string[]): EntityQuery;
- expand(propertyPaths: string): EntityQuery;
- static from(resourceName: string): EntityQuery;
- from(resourceName: string): EntityQuery;
- static fromEntities(entity: Entity): EntityQuery;
- static fromEntities(entities: Entity[]): EntityQuery;
- static fromEntityKey(entityKey: EntityKey): EntityQuery;
- static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery;
- inlineCount(enabled?: boolean): EntityQuery;
- orderBy(propertyPaths: string): EntityQuery;
- orderBy(propertyPaths: string[]): EntityQuery;
- orderByDesc(propertyPaths: string): EntityQuery;
- orderByDesc(propertyPaths: string[]): EntityQuery;
- select(propertyPaths: string): EntityQuery;
- select(propertyPaths: string[]): EntityQuery;
- skip(count: number): EntityQuery;
- take(count: number): EntityQuery;
- top(count: number): EntityQuery;
- toType(typeName: string): EntityQuery;
- toType(type: EntityType): EntityQuery;
-
- using(obj: EntityManager): EntityQuery;
- using(obj: MergeStrategySymbol): EntityQuery;
- using(obj: FetchStrategySymbol): EntityQuery;
- using(obj: JsonResultsAdapter): EntityQuery;
-
- where(predicate: Predicate): EntityQuery;
- where(property: string, operator: string, value: any): EntityQuery;
- where(property: string, operator: FilterQueryOpSymbol, value: any): EntityQuery;
- where(predicate: FilterQueryOpSymbol): EntityQuery;
- withParameters(params: Object): EntityQuery;
- }
-
- interface OrderByClause {
- }
-
- class EntityStateSymbol extends breezeCore.EnumSymbol {
- isAdded(): boolean;
- isAddedModifiedOrDeleted(): boolean;
- isDeleted(): boolean;
- isDetached(): boolean;
- isModified(): boolean;
- isUnchanged(): boolean;
- isUnchangedOrModified(): boolean;
- }
- interface EntityState extends breezeCore.IEnum {
- Added: EntityStateSymbol;
- Deleted: EntityStateSymbol;
- Detached: EntityStateSymbol;
- Modified: EntityStateSymbol;
- Unchanged: EntityStateSymbol;
- }
- var EntityState: EntityState;
-
- class EntityType implements IStructuralType {
- autoGeneratedKeyType: AutoGeneratedKeyType;
- complexProperties: DataProperty[];
- concurrencyProperties: DataProperty[];
- dataProperties: DataProperty[];
- defaultResourceName: string;
- foreignKeyProperties: DataProperty[];
- keyProperties: DataProperty[];
- metadataStore: MetadataStore;
- name: string;
- namespace: string;
- navigationProperties: NavigationProperty[];
- shortName: string;
- unmappedProperties: DataProperty[];
- validators: Validator[];
-
- constructor (config: MetadataStore);
- constructor (config: EntityTypeOptions);
-
- addProperty(property: IProperty): void;
- addValidator(validator: Validator, property?: IProperty): void;
- createEntity(initialValues?: Object): Entity;
- getDataProperty(propertyName: string): DataProperty;
- getEntityCtor(): Function;
- getNavigationProperty(propertyName: string): NavigationProperty;
- getProperties(): IProperty[];
- getProperty(propertyPath: string, throwIfNotFound?: boolean): IProperty;
- getPropertyNames(): string[];
- setProperties(config: EntityTypeProperties): void;
- toString(): string;
- }
-
- interface EntityTypeOptions {
- shortName?: string;
- namespace?: string;
- autogeneratedKeyType?: AutoGeneratedKeyType;
- defaultResourceName?: string;
- }
-
- interface EntityTypeProperties {
- autogeneratedKeyType?: AutoGeneratedKeyType;
- defaultResourceName?: string;
- }
-
- class FetchStrategySymbol extends breezeCore.EnumSymbol {
- }
- interface FetchStrategy extends breezeCore.IEnum {
- FromLocalCache: FetchStrategySymbol;
- FromServer: FetchStrategySymbol;
- }
- var FetchStrategy: FetchStrategy;
-
- class FilterQueryOpSymbol extends breezeCore.EnumSymbol {
- }
- interface FilterQueryOp extends breezeCore.IEnum {
- Contains: FilterQueryOpSymbol;
- EndsWith: FilterQueryOpSymbol;
- Equals: FilterQueryOpSymbol;
- GreaterThan: FilterQueryOpSymbol;
- GreaterThanOrEqual: FilterQueryOpSymbol;
- LessThan: FilterQueryOpSymbol;
- LessThanOrEqual: FilterQueryOpSymbol;
- NotEquals: FilterQueryOpSymbol;
- StartsWith: FilterQueryOpSymbol;
- }
- var FilterQueryOp: FilterQueryOp;
-
- class LocalQueryComparisonOptions {
- static caseInsensitiveSQL: LocalQueryComparisonOptions;
- static defaultInstance: LocalQueryComparisonOptions;
-
- constructor (config: { name?: string; isCaseSensitive?: boolean; usesSql92CompliantStringComparison?: boolean; });
-
- setAsDefault(): void;
- }
-
- class MergeStrategySymbol extends breezeCore.EnumSymbol {
- }
- interface MergeStrategy extends breezeCore.IEnum {
- OverwriteChanges: MergeStrategySymbol;
- PreserveChanges: MergeStrategySymbol;
- }
- var MergeStrategy: MergeStrategy;
-
- class MetadataStore {
- namingConvention: NamingConvention;
-
- constructor (config?: MetadataStoreOptions);
- addDataService(dataService: DataService): void;
- addEntityType(structuralType: IStructuralType): void;
- exportMetadata(): string;
- fetchMetadata(dataService: string, callback?: (data) => void , errorCallback?: breezeCore.ErrorCallback): Promise;
- fetchMetadata(dataService: DataService, callback?: (data) => void , errorCallback?: breezeCore.ErrorCallback): Promise;
- getDataService(serviceName: string): DataService;
- getEntityType(entityTypeName: string, okIfNotFound?: boolean): IStructuralType;
- getEntityTypes(): IStructuralType[];
- hasMetadataFor(serviceName: string): boolean;
- static importMetadata(exportedString: string): MetadataStore;
- importMetadata(exportedString: string): MetadataStore;
- isEmpty(): boolean;
- registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void;
- trackUnmappedType(entityCtor: Function, interceptor?: Function);
- setEntityTypeForResourceName(resourceName: string, entityTypeOrName: string): void;
- }
-
- interface MetadataStoreOptions {
- namingConvention?: NamingConvention;
- localQueryComparisonOptions?: LocalQueryComparisonOptions;
- }
-
- class NamingConvention {
- static camelCase: NamingConvention;
- static defaultInstance: NamingConvention;
- static none: NamingConvention;
- name: string;
-
- constructor (config: NamingConventionOptions);
-
- clientPropertyNameToServer(clientPropertyName: string): string;
- clientPropertyNameToServer(clientPropertyName: string, property: IProperty): string;
-
- serverPropertyNameToClient(serverPropertyName: string): string;
- serverPropertyNameToClient(serverPropertyName: string, property: IProperty): string;
-
- setAsDefault();
- }
-
- interface NamingConventionOptions {
- serverPropertyNameToClient?: (name: string) => string;
- clientPropertyNameToServer?: (name: string) => string;
- }
-
- class NavigationProperty implements IProperty {
- associationName: string;
- entityType: EntityType;
- foreignKeyNames: string[];
- inverse: NavigationProperty;
- isDataProperty: boolean;
- isNavigationProperty: boolean;
- isScalar: boolean;
- name: string;
- parentEntityType: EntityType;
- relatedDataProperties: DataProperty[];
- validators: Validator[];
-
- constructor (config: NavigationPropertyOptions);
- }
-
- interface NavigationPropertyOptions {
- name?: string;
- nameOnServer?: string;
- entityTypeName: string;
- isScalar?: boolean;
- associationName?: string;
- foreignKeyNames?: string[];
- foreignKeyNamesOnServer?: string[];
- validators?: Validator[];
- }
-
- class Predicate {
- constructor (property: string, operator: string, value: any, valueIsLiteral?: boolean);
- constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean);
-
- and: PredicateMethod;
- static and: PredicateMethod;
-
- static create: PredicateMethod;
-
- static isPredicate(o: any): boolean;
-
- static not(predicate: Predicate): Predicate;
- not(): Predicate;
-
- static or: PredicateMethod;
- or: PredicateMethod;
-
- toFunction(): Function;
- toString(): string;
- validate(entityType: EntityType): void;
- }
-
- interface PredicateMethod {
- (predicates: Predicate[]): Predicate;
- (...predicates: Predicate[]): Predicate;
- (property: string, operator: string, value: any, valueIsLiteral?: boolean): Predicate;
- (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean): Predicate;
- }
-
- class Promise {
- fail(errorCallback: Function): Promise;
- fin(finallyCallback: Function): Promise;
- then(callback: Function): Promise;
- }
-
- class QueryOptions {
- static defaultInstance: QueryOptions;
- fetchStrategy: FetchStrategySymbol;
- mergeStrategy: MergeStrategySymbol;
-
- constructor (config?: QueryOptionsConfiguration);
-
- setAsDefault(): void;
- using(config: QueryOptionsConfiguration): QueryOptions;
- using(config: MergeStrategySymbol): QueryOptions;
- using(config: FetchStrategySymbol): QueryOptions;
- }
-
- interface QueryOptionsConfiguration {
- fetchStrategy?: FetchStrategySymbol;
- mergeStrategy?: MergeStrategySymbol;
- }
-
- class SaveOptions {
- allowConcurrentSaves: boolean;
- static defaultInstance: SaveOptions;
-
- constructor (config?: { allowConcurrentSaves?: boolean; });
-
- setAsDefault(): SaveOptions;
- }
-
- class ValidationError {
- context: any;
- errorMessage: string;
- property: IProperty;
- propertyName: string;
- validator: Validator;
-
- constructor (validator: Validator, context: any, errorMessage: string);
- }
-
- class ValidationOptions {
- static defaultInstance: ValidationOptions;
- validateOnAttach: boolean;
- validateOnPropertyChange: boolean;
- validateOnQuery: boolean;
- validateOnSave: boolean;
-
- constructor (config?: ValidationOptionsConfiguration);
-
- setAsDefault(): ValidationOptions;
- using(config: ValidationOptionsConfiguration): ValidationOptions;
- }
-
- interface ValidationOptionsConfiguration {
- validateOnAttach?: boolean;
- validateOnSave?: boolean;
- validateOnQuery?: boolean;
- validateOnPropertyChange?: boolean;
- }
-
- class Validator {
- static messageTemplates: any;
-
- constructor (name: string, validatorFn: ValidatorFunction, context?: any);
-
- static bool(): Validator;
- static byte(): Validator;
- static date(): Validator;
- static duration(): Validator;
- getMessage(): string;
- static guid(): Validator;
- static int16(): Validator;
- static int32(): Validator;
- static int64(): Validator;
- static maxLength(context: { maxLength: number; }): Validator;
- static number(): Validator;
- static required(): Validator;
- static string(): Validator;
- static stringLength(context: { maxLength: number; minLength: number; }): Validator;
- validate(value: any, context?: any): ValidationError;
- }
-
- interface ValidatorFunction {
- (value: any, context: ValidatorFunctionContext): void;
- }
-
- interface ValidatorFunctionContext {
- value: any;
- validatorName: string;
- displayName: string;
- messageTemplate: string;
- message?: string;
- }
-}
\ No newline at end of file
+// Type definitions for Breeze 1.4
+// Project: http://www.breezejs.com/
+// Definitions by: Boris Yankov ,
+// IdeaBlade
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+// Updated Jan 14 2011 - Jay Traband ( www.ideablade.com).
+// Updated March 27 2013 - John Lantz (www.ideablade.com).
+// Updated Aug 13 2013 - Steve Schmitt ( www.ideablade.com).
+
+///
+
+declare module breeze.core {
+
+ interface ErrorCallback {
+ (error: Error): void;
+ }
+
+ interface IEnum {
+ contains(object: any): boolean;
+ fromName(name: string): EnumSymbol;
+ getNames(): string[];
+ getSymbols(): EnumSymbol[];
+ }
+
+ class Enum implements IEnum {
+ constructor (name: string, methodObj?: any);
+
+ addSymbol(propertiesObj?: any): EnumSymbol;
+ contains(object: any): boolean;
+ fromName(name: string): EnumSymbol;
+ getNames(): string[];
+ getSymbols(): EnumSymbol[];
+ static isSymbol(object: any): boolean;
+ seal(): void;
+ }
+
+ class EnumSymbol {
+ parentEnum: IEnum;
+
+ getName(): string;
+ toString(): string;
+ }
+
+ class Event {
+ constructor (name: string, publisher: any, defaultErrorCallback?: ErrorCallback);
+
+ static enable(eventName: string, target: any): void;
+ static enable(eventName: string, target: any, isEnabled: boolean): void;
+ static enable(eventName: string, target: any, isEnabled: Function): void;
+
+ static isEnabled(eventName: string, target: any): boolean;
+ publish(data: any, publishAsync?: boolean, errorCallback?: ErrorCallback): void;
+ publishAsync(data: any, errorCallback?: ErrorCallback): void;
+ subscribe(callback?: (data: any) => void ): number;
+ unsubscribe(unsubKey: number): boolean;
+ }
+
+ export function objectForEach(obj: Object, kvfn: (key:string, value:any) => void): void;
+
+ export function extend(target: Object, source: Object): Object;
+ export function propEq(propertyName: string, value: any): (obj: Object) => boolean;
+ export function pluck(propertyName: string): (obj: Object) => any;
+ export function arrayEquals(a1:Array, a2:Array, equalsFn: (e1:any, e2:any) => boolean): boolean;
+ export function arrayFirst(a1:Array, predicate: (e:any) => boolean): any;
+ export function arrayIndexOf(a1: Array, predicate: (e: any) => boolean): number;
+ export function arrayRemoveItem(array: Array, item: any, shouldRemoveMultiple: boolean): any;
+ export function arrayRemoveItem(array: Array, predicate: (e: any) => boolean, shouldRemoveMultiple: boolean): any;
+ export function arrayZip(a1: Array, a2: Array, callback: (e1:any, e2:any) => any): Array;
+
+ export function requireLib(libnames: string, errMessage: string): Object;
+ export function using(obj: Object, property: string, tempValue: any, fn: () => any): any;
+ export function memoize(fn:(...any) => any): any;
+ export function getUuid(): string;
+ export function durationToSeconds(duration: string): number;
+
+ export function isDate(o: any): boolean;
+ export function isGuid(o: any): boolean;
+ export function isDuration(o: any): boolean;
+ export function isFunction(o: any): boolean;
+ export function isEmpty(o: any): boolean;
+ export function isNumeric(o: any): boolean;
+
+ export function stringStartsWith(str: string, prefix: string): boolean;
+ export function stringEndsWith(str: string, suffix: string): boolean;
+ export function formatString(format: string, ...args: any[]): string;
+}
+
+declare module breeze {
+
+ interface Entity {
+ entityAspect: EntityAspect;
+ entityType: EntityType;
+ }
+
+ interface ComplexObject {
+ complexAspect: ComplexAspect;
+ complexType: ComplexType;
+ }
+
+ interface IProperty {
+ name: string;
+ parentType: IStructuralType;
+ validators: Validator[];
+ isDataProperty: boolean;
+ isNavigationProperty: boolean;
+ }
+
+ interface IStructuralType {
+ complexProperties: DataProperty[];
+ dataProperties: DataProperty[];
+ name: string;
+ namespace: string;
+ shortName: string;
+ unmappedProperties: DataProperty[];
+ validators: Validator[];
+ }
+
+ class AutoGeneratedKeyType {
+ static Identity: AutoGeneratedKeyType;
+ static KeyGenerator: AutoGeneratedKeyType;
+ static None: AutoGeneratedKeyType;
+ }
+
+ class ComplexAspect {
+ complexObject: ComplexObject;
+ getEntityAspect(): EntityAspect;
+ parent: Object;
+ parentProperty: DataProperty;
+ getPropertyPath(propName: string): string;
+ originalValues: Object;
+ }
+
+ class ComplexType implements IStructuralType {
+ complexProperties: DataProperty[];
+ dataProperties: DataProperty[];
+ name: string;
+ namespace: string;
+ shortName: string;
+ unmappedProperties: DataProperty[];
+ validators: Validator[];
+ addProperty(dataProperty: DataProperty);
+ getProperties(): DataProperty[];
+ }
+
+ class DataProperty implements IProperty {
+ complexTypeName: string;
+ concurrencyMode: string;
+ dataType: DataTypeSymbol;
+ defaultValue: any;
+ fixedLength: boolean;
+ isComplexProperty: boolean;
+ isDataProperty: boolean;
+ isInherited: boolean;
+ isNavigationProperty: boolean;
+ isNullable: boolean;
+ isPartOfKey: boolean;
+ isUnmapped: boolean;
+
+ maxLength: number;
+ name: string;
+ nameOnServer: string;
+ parentType: IStructuralType;
+ relatedNavigationProperty: NavigationProperty;
+ validators: Validator[];
+ constructor (config: DataPropertyOptions);
+ }
+
+ interface DataPropertyOptions {
+ complexTypeName?: string;
+ concurrencyMode?: string;
+ dataType?: DataTypeSymbol;
+ defaultValue?: any;
+ fixedLength?: boolean;
+ isNullable?: boolean;
+ isPartOfKey?: boolean;
+ isUnmapped?: boolean;
+ maxLength?: number;
+ name?: string;
+ nameOnServer?: string;
+ validators?: Validator[];
+ }
+
+ class DataService {
+ adapterInstance: DataServiceAdapter;
+ adapterName: string;
+ hasServerMetadata: boolean;
+ serviceName: string;
+ jsonResultsAdapter: JsonResultsAdapter;
+ useJsonp: boolean;
+ constructor(config: DataServiceOptions);
+ using(config: DataServiceOptions): DataService;
+ }
+
+ interface DataServiceOptions {
+ serviceName?: string;
+ adapterName?: string;
+ hasServerMetadata?: boolean;
+ jsonResultsAdapter?: JsonResultsAdapter;
+ useJsonp?: boolean;
+ }
+
+ class DataServiceAdapter {
+ checkForRecomposition(interfaceInitializedArgs: { interfaceName: string; isDefault: boolean}): void;
+ initialize(): void;
+ fetchMetadata(metadataStore: MetadataStore, dataService: DataService): Q.Promise;
+ executeQuery(mappingContext: Object): Q.Promise;
+ saveChanges(saveContext: { resourceName: string }, saveBundle: Object): Q.Promise;
+ JsonResultsAdapter: JsonResultsAdapter;
+ }
+
+ class JsonResultsAdapter {
+ name: string;
+ extractResults: (data: {}) => {};
+ visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: boolean; };
+ constructor(config: {
+ name: string;
+ extractResults?: (data: {}) => {};
+ visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: boolean; };
+ });
+ }
+
+ interface QueryContext {
+ url: string;
+ query: any; // how to also say it could be an EntityQuery or a string
+ entityManager: EntityManager;
+ dataService: DataService;
+ queryOptions: QueryOptions;
+ }
+
+ interface NodeContext {
+ nodeType: string;
+ }
+
+ class DataTypeSymbol extends breeze.core.EnumSymbol {
+ defaultValue: any;
+ isNumeric: boolean;
+ isDate: boolean;
+ }
+ interface DataType extends breeze.core.IEnum {
+ Binary: DataTypeSymbol;
+ Boolean: DataTypeSymbol;
+ Byte: DataTypeSymbol;
+ DateTime: DataTypeSymbol;
+ DateTimeOffset: DataTypeSymbol;
+ Decimal: DataTypeSymbol;
+ Double: DataTypeSymbol;
+ Guid: DataTypeSymbol;
+ Int16: DataTypeSymbol;
+ Int32: DataTypeSymbol;
+ Int64: DataTypeSymbol;
+ Single: DataTypeSymbol;
+ String: DataTypeSymbol;
+ Time: DataTypeSymbol;
+ Undefined: DataTypeSymbol;
+ toDataType(typeName: string): DataTypeSymbol;
+ parseDateFromServer(date: any): Date;
+ defaultValue: any;
+ isNumeric: boolean;
+ }
+ var DataType: DataType;
+
+ class EntityActionSymbol extends breeze.core.EnumSymbol {
+ }
+ interface EntityAction extends breeze.core.IEnum {
+ AcceptChanges: EntityActionSymbol;
+ Attach: EntityActionSymbol;
+ AttachOnImport: EntityActionSymbol;
+ AttachOnQuery: EntityActionSymbol;
+ Clear: EntityActionSymbol;
+ Detach: EntityActionSymbol;
+ EntityStateChange: EntityActionSymbol;
+ MergeOnImport: EntityActionSymbol;
+ MergeOnSave: EntityActionSymbol;
+ MergeOnQuery: EntityActionSymbol;
+ PropertyChange: EntityActionSymbol;
+ RejectChanges: EntityActionSymbol;
+ }
+ var EntityAction: EntityAction;
+
+ class EntityAspect {
+ entity: Entity;
+ entityManager: EntityManager;
+ entityState: EntityStateSymbol;
+ isBeingSaved: boolean;
+ originalValues: Object;
+
+ propertyChanged: PropertyChangedEvent;
+ validationErrorsChanged: ValidationErrorsChangedEvent;
+
+ acceptChanges(): void;
+ addValidationError(validationError: ValidationError): void;
+ clearValidationErrors(): void;
+ getKey(forceRefresh?: boolean): EntityKey;
+
+ getValidationErrors(): ValidationError[];
+ getValidationErrors(property: string): ValidationError[];
+ getValidationErrors(property: IProperty): ValidationError[];
+ hasValidationErrors: boolean;
+
+ loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): Q.Promise;
+ loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): Q.Promise;
+
+ rejectChanges(): void;
+
+ removeValidationError(validator: Validator): void;
+ removeValidationError(validator: Validator, property: DataProperty): void;
+ removeValidationError(validator: Validator, property: NavigationProperty): void;
+ removeValidationError(validationError: ValidationError): void;
+
+ setDeleted(): void;
+ setDetached(): void;
+ setModified(): void;
+ setUnchanged(): void;
+ validateEntity(): boolean;
+
+ validateProperty(property: string, context?: any): boolean;
+ validateProperty(property: DataProperty, context?: any): boolean;
+ validateProperty(property: NavigationProperty, context?: any): boolean;
+ }
+
+ class PropertyChangedEventArgs {
+ entity: Entity;
+ propertyName: string;
+ oldValue: any;
+ newValue: any;
+ }
+
+ class PropertyChangedEvent extends breeze.core.Event {
+ subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number;
+ }
+
+ class ValidationErrorsChangedEventArgs {
+ entity: Entity;
+ added: ValidationError[];
+ removed: ValidationError[];
+ }
+
+ class ValidationErrorsChangedEvent extends breeze.core.Event {
+ subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number;
+ }
+
+ class EntityKey {
+ constructor (entityType: EntityType, keyValue: any);
+ constructor (entityType: EntityType, keyValues: any[]);
+
+ equals(entityKey: EntityKey): boolean;
+ static equals(k1: EntityKey, k2: EntityKey): boolean;
+ entityType: EntityType;
+ values: any[];
+ }
+
+ interface EntityByKeyResult {
+ entity: Entity;
+ entityKey: EntityKey;
+ fromCache: boolean;
+ }
+
+ class EntityManager {
+ dataService: DataService;
+ keyGeneratorCtor: Function;
+ metadataStore: MetadataStore;
+ queryOptions: QueryOptions;
+ saveOptions: SaveOptions;
+ serviceName: string;
+ validationOptions: ValidationOptions;
+
+ entityChanged: EntityChangedEvent;
+ hasChangesChanged: HasChangesChangedEvent;
+ validationErrorsChanged: ValidationErrorsChangedEvent;
+
+ constructor (config?: EntityManagerOptions);
+ constructor (config?: string);
+
+ addEntity(entity: Entity): Entity;
+ attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity;
+ clear(): void;
+ createEmptyCopy(): EntityManager;
+ createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol) : Entity;
+ createEntity(entityType: EntityType, config?: {}, entityState?: EntityStateSymbol): Entity;
+ detachEntity(entity: Entity): boolean;
+ executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Q.Promise;
+ executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Q.Promise;
+
+ executeQueryLocally(query: EntityQuery): Entity[];
+ exportEntities(entities?: Entity[]): string;
+ fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: boolean): Q.Promise;
+ fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: boolean): Q.Promise;
+ fetchEntityByKey(entityKey: EntityKey): Q.Promise;
+ fetchMetadata(callback?: (schema: any) => void , errorCallback?: breeze.core.ErrorCallback): Q.Promise;
+ generateTempKeyValue(entity: Entity): any;
+ getChanges(): Entity[];
+ getChanges(entityTypeName: string): Entity[];
+ getChanges(entityTypeNames: string[]): Entity[];
+ getChanges(entityType: EntityType): Entity[];
+ getChanges(entityTypes: EntityType[]): Entity[];
+
+ getEntities(entityTypeName: string, entityState?: EntityStateSymbol): Entity[];
+ getEntities(entityTypeNames?: string[], entityState?: EntityStateSymbol): Entity[];
+ getEntities(entityTypeName?: string, entityStates?: EntityStateSymbol[]): Entity[];
+ getEntities(entityTypeNames?: string[], entityStates?: EntityStateSymbol[]): Entity[];
+
+ getEntities(entityType: EntityType, entityState?: EntityStateSymbol): Entity[];
+ getEntities(entityTypes?: EntityType[], entityState?: EntityStateSymbol): Entity[];
+ getEntities(entityType?: EntityType, entityStates?: EntityStateSymbol[]): Entity[];
+ getEntities(entityTypes?: EntityType[], entityStates?: EntityStateSymbol[]): Entity[];
+
+ getEntityByKey(typeName: string, keyValue: any): Entity;
+ getEntityByKey(typeName: string, keyValues: any[]): Entity;
+ getEntityByKey(entityKey: EntityKey): Entity;
+
+ hasChanges(): boolean;
+ hasChanges(entityTypeName: string): boolean;
+ hasChanges(entityTypeNames: string[]): boolean;
+ hasChanges(entityType: EntityType): boolean;
+ hasChanges(entityTypes: EntityType[]): boolean;
+
+ static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
+ static importEntities(exportedData: Object, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
+ importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
+ importEntities(exportedData: Object, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
+
+ rejectChanges(): Entity[];
+ saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Q.Promise;
+ setProperties(config: EntityManagerProperties): void;
+ }
+
+ interface EntityManagerOptions {
+ serviceName?: string;
+ dataService?: DataService;
+ metadataStore?: MetadataStore;
+ queryOptions?: QueryOptions;
+ saveOptions?: SaveOptions;
+ validationOptions?: ValidationOptions;
+ keyGeneratorCtor?: Function;
+ }
+
+ interface EntityManagerProperties {
+ serviceName?: string;
+ dataService?: DataService;
+ queryOptions?: QueryOptions;
+ saveOptions?: SaveOptions;
+ validationOptions?: ValidationOptions;
+ keyGeneratorCtor?: Function;
+ }
+
+ interface ExecuteQuerySuccessCallback {
+ (data: QueryResult): void;
+ }
+
+ interface ExecuteQueryErrorCallback {
+ (error: { query: EntityQuery; XHR: XMLHttpRequest; entityManager: EntityManager}): void;
+ }
+
+ interface SaveChangesSuccessCallback {
+ (saveResult: SaveResult): void;
+ }
+
+ interface SaveChangesErrorCallback {
+ (error: { XHR: XMLHttpRequest; }): void;
+ }
+
+ class EntityChangedEventArgs {
+ entity: Entity;
+ entityAction: EntityActionSymbol;
+ args: Object;
+ }
+
+ class EntityChangedEvent extends breeze.core.Event {
+ subscribe(callback?: (data: EntityChangedEventArgs) => void ): number;
+ }
+
+ class HasChangesChangedEventArgs {
+ entityManager: EntityManager;
+ hasChanges: boolean;
+ }
+
+ class HasChangesChangedEvent extends breeze.core.Event {
+ subscribe(callback?: (data: HasChangesChangedEventArgs) => void ): number;
+ }
+
+ class EntityQuery {
+ entityManager: EntityManager;
+ orderByClause: OrderByClause;
+ parameters: Object;
+ queryOptions: QueryOptions;
+ resourceName: string;
+ resultEntityType: EntityType;
+ skipCount: number;
+ takeCount: number;
+ wherePredicate: Predicate;
+
+ constructor (resourceName?: string);
+
+ execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Q.Promise;
+ executeLocally(): Entity[];
+ expand(propertyPaths: string[]): EntityQuery;
+ expand(propertyPaths: string): EntityQuery;
+ static from(resourceName: string): EntityQuery;
+ from(resourceName: string): EntityQuery;
+ static fromEntities(entity: Entity): EntityQuery;
+ static fromEntities(entities: Entity[]): EntityQuery;
+ static fromEntityKey(entityKey: EntityKey): EntityQuery;
+ static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery;
+ inlineCount(enabled?: boolean): EntityQuery;
+ orderBy(propertyPaths: string): EntityQuery;
+ orderBy(propertyPaths: string[]): EntityQuery;
+ orderByDesc(propertyPaths: string): EntityQuery;
+ orderByDesc(propertyPaths: string[]): EntityQuery;
+ select(propertyPaths: string): EntityQuery;
+ select(propertyPaths: string[]): EntityQuery;
+ skip(count: number): EntityQuery;
+ take(count: number): EntityQuery;
+ top(count: number): EntityQuery;
+ toType(typeName: string): EntityQuery;
+ toType(type: EntityType): EntityQuery;
+
+ using(obj: EntityManager): EntityQuery;
+ using(obj: DataService): EntityQuery;
+ using(obj: JsonResultsAdapter): EntityQuery;
+ using(obj: QueryOptions): EntityQuery;
+ using(obj: MergeStrategySymbol): EntityQuery;
+ using(obj: FetchStrategySymbol): EntityQuery;
+
+ where(predicate: Predicate): EntityQuery;
+ where(property: string, operator: string, value: any): EntityQuery;
+ where(property: string, operator: FilterQueryOpSymbol, value: any): EntityQuery;
+ where(predicate: FilterQueryOpSymbol): EntityQuery;
+ withParameters(params: Object): EntityQuery;
+ }
+
+ interface OrderByClause {
+ }
+
+ class EntityStateSymbol extends breeze.core.EnumSymbol {
+ isAdded(): boolean;
+ isAddedModifiedOrDeleted(): boolean;
+ isDeleted(): boolean;
+ isDetached(): boolean;
+ isModified(): boolean;
+ isUnchanged(): boolean;
+ isUnchangedOrModified(): boolean;
+ }
+ interface EntityState extends breeze.core.IEnum {
+ Added: EntityStateSymbol;
+ Deleted: EntityStateSymbol;
+ Detached: EntityStateSymbol;
+ Modified: EntityStateSymbol;
+ Unchanged: EntityStateSymbol;
+ }
+ var EntityState: EntityState;
+
+ class EntityType implements IStructuralType {
+ autoGeneratedKeyType: AutoGeneratedKeyType;
+ baseEntityType: EntityType;
+ complexProperties: DataProperty[];
+ concurrencyProperties: DataProperty[];
+ dataProperties: DataProperty[];
+ defaultResourceName: string;
+ foreignKeyProperties: DataProperty[];
+ isAbstract: boolean;
+ keyProperties: DataProperty[];
+ metadataStore: MetadataStore;
+ name: string;
+ namespace: string;
+ navigationProperties: NavigationProperty[];
+ shortName: string;
+ unmappedProperties: DataProperty[];
+ validators: Validator[];
+
+ constructor (config: MetadataStore);
+ constructor (config: EntityTypeOptions);
+
+ addProperty(property: IProperty): void;
+ addValidator(validator: Validator, property?: IProperty): void;
+ createEntity(initialValues?: Object): Entity;
+ getCtor(): Function;
+ getDataProperty(propertyName: string): DataProperty;
+ getNavigationProperty(propertyName: string): NavigationProperty;
+ getProperties(): IProperty[];
+ getProperty(propertyPath: string, throwIfNotFound?: boolean): IProperty;
+ getPropertyNames(): string[];
+ getSelfAndSubtypes(): EntityType[];
+ isSubtypeOf(entityType: EntityType): boolean;
+ setProperties(config: EntityTypeProperties): void;
+ toString(): string;
+ }
+
+ interface EntityTypeOptions {
+ shortName?: string;
+ namespace?: string;
+ autoGeneratedKeyType?: AutoGeneratedKeyType;
+ defaultResourceName?: string;
+ dataProperties?: DataProperty[];
+ navigationProperties?: NavigationProperty[];
+ }
+
+ interface EntityTypeProperties {
+ autoGeneratedKeyType?: AutoGeneratedKeyType;
+ defaultResourceName?: string;
+ }
+
+ class FetchStrategySymbol extends breeze.core.EnumSymbol {
+ }
+ interface FetchStrategy extends breeze.core.IEnum {
+ FromLocalCache: FetchStrategySymbol;
+ FromServer: FetchStrategySymbol;
+ }
+ var FetchStrategy: FetchStrategy;
+
+ class FilterQueryOpSymbol extends breeze.core.EnumSymbol {
+ }
+ interface FilterQueryOp extends breeze.core.IEnum {
+ Contains: FilterQueryOpSymbol;
+ EndsWith: FilterQueryOpSymbol;
+ Equals: FilterQueryOpSymbol;
+ GreaterThan: FilterQueryOpSymbol;
+ GreaterThanOrEqual: FilterQueryOpSymbol;
+ IsTypeOf: FilterQueryOpSymbol;
+ LessThan: FilterQueryOpSymbol;
+ LessThanOrEqual: FilterQueryOpSymbol;
+ NotEquals: FilterQueryOpSymbol;
+ StartsWith: FilterQueryOpSymbol;
+ }
+ var FilterQueryOp: FilterQueryOp;
+
+ class LocalQueryComparisonOptions {
+ static caseInsensitiveSQL: LocalQueryComparisonOptions;
+ static defaultInstance: LocalQueryComparisonOptions;
+
+ constructor (config: { name?: string; isCaseSensitive?: boolean; usesSql92CompliantStringComparison?: boolean; });
+
+ setAsDefault(): void;
+ }
+
+ class MergeStrategySymbol extends breeze.core.EnumSymbol {
+ }
+ interface MergeStrategy extends breeze.core.IEnum {
+ OverwriteChanges: MergeStrategySymbol;
+ PreserveChanges: MergeStrategySymbol;
+ }
+ var MergeStrategy: MergeStrategy;
+
+ class MetadataStore {
+ constructor();
+ constructor(config?: MetadataStoreOptions);
+ namingConvention: NamingConvention;
+ addDataService(dataService: DataService): void;
+ addEntityType(structuralType: IStructuralType): void;
+ exportMetadata(): string;
+ fetchMetadata(dataService: string, callback?: (data) => void , errorCallback?: breeze.core.ErrorCallback): Q.Promise;
+ fetchMetadata(dataService: DataService, callback?: (data) => void , errorCallback?: breeze.core.ErrorCallback): Q.Promise;
+ getDataService(serviceName: string): DataService;
+ getEntityType(entityTypeName: string, okIfNotFound?: boolean): IStructuralType;
+ getEntityTypes(): IStructuralType[];
+ hasMetadataFor(serviceName: string): boolean;
+ static importMetadata(exportedString: string): MetadataStore;
+ importMetadata(exportedString: string): MetadataStore;
+ isEmpty(): boolean;
+ registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void;
+ trackUnmappedType(entityCtor: Function, interceptor?: Function);
+ setEntityTypeForResourceName(resourceName: string, entityType: EntityType): void;
+ setEntityTypeForResourceName(resourceName: string, entityTypeName: string): void;
+ getEntityTypeNameForResourceName(resourceName: string): string;
+ }
+
+ interface MetadataStoreOptions {
+ namingConvention?: NamingConvention;
+ localQueryComparisonOptions?: LocalQueryComparisonOptions;
+ }
+
+ class NamingConvention {
+ static camelCase: NamingConvention;
+ static defaultInstance: NamingConvention;
+ static none: NamingConvention;
+
+ constructor (config: NamingConventionOptions);
+
+ clientPropertyNameToServer(clientPropertyName: string): string;
+ clientPropertyNameToServer(clientPropertyName: string, property: IProperty): string;
+
+ serverPropertyNameToClient(serverPropertyName: string): string;
+ serverPropertyNameToClient(serverPropertyName: string, property: IProperty): string;
+
+ setAsDefault();
+ }
+
+ interface NamingConventionOptions {
+ serverPropertyNameToClient?: (name: string) => string;
+ clientPropertyNameToServer?: (name: string) => string;
+ }
+
+ class NavigationProperty implements IProperty {
+ associationName: string;
+ entityType: EntityType;
+ foreignKeyNames: string[];
+ inverse: NavigationProperty;
+ isDataProperty: boolean;
+ isNavigationProperty: boolean;
+ isScalar: boolean;
+ name: string;
+ parentType: IStructuralType;
+ relatedDataProperties: DataProperty[];
+ validators: Validator[];
+
+ constructor (config: NavigationPropertyOptions);
+ }
+
+ interface NavigationPropertyOptions {
+ name?: string;
+ nameOnServer?: string;
+ entityTypeName: string;
+ isScalar?: boolean;
+ associationName?: string;
+ foreignKeyNames?: string[];
+ foreignKeyNamesOnServer?: string[];
+ validators?: Validator[];
+ }
+
+ class Predicate {
+ constructor (property: string, operator: string, value: any, valueIsLiteral?: boolean);
+ constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean);
+
+ and: PredicateMethod;
+ static and: PredicateMethod;
+
+ static create: PredicateMethod;
+
+ static isPredicate(o: any): boolean;
+
+ static not(predicate: Predicate): Predicate;
+ not(): Predicate;
+
+ static or: PredicateMethod;
+ or: PredicateMethod;
+
+ toFunction(): Function;
+ toString(): string;
+ validate(entityType: EntityType): void;
+ }
+
+ interface PredicateMethod {
+ (predicates: Predicate[]): Predicate;
+ (...predicates: Predicate[]): Predicate;
+ (property: string, operator: string, value: any, valueIsLiteral?: boolean): Predicate;
+ (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean): Predicate;
+ }
+
+ class QueryOptions {
+ static defaultInstance: QueryOptions;
+ fetchStrategy: FetchStrategySymbol;
+ mergeStrategy: MergeStrategySymbol;
+
+ constructor (config?: QueryOptionsConfiguration);
+
+ setAsDefault(): void;
+ using(config: QueryOptionsConfiguration): QueryOptions;
+ using(config: MergeStrategySymbol): QueryOptions;
+ using(config: FetchStrategySymbol): QueryOptions;
+ }
+
+ interface QueryOptionsConfiguration {
+ fetchStrategy?: FetchStrategySymbol;
+ mergeStrategy?: MergeStrategySymbol;
+ }
+
+ interface QueryResult {
+ results: Entity[];
+ query: EntityQuery;
+ XHR: XMLHttpRequest;
+ entityManager?: EntityManager;
+ inlineCount?: number
+ }
+
+ class SaveOptions {
+ allowConcurrentSaves: boolean;
+ resourceName: string;
+ dataService: DataService;
+ tag: string;
+ static defaultInstance: SaveOptions;
+
+ constructor (config?: { allowConcurrentSaves?: boolean; });
+
+ setAsDefault(): SaveOptions;
+ using(config: SaveOptionsConfiguration): SaveOptions;
+ }
+
+ interface SaveOptionsConfiguration {
+ allowConcurrentSaves?: boolean;
+ resourceName?: string;
+ dataService?: DataService;
+ tag?: string;
+ }
+
+ interface SaveResult {
+ entities: Entity[];
+ keyMappings: any;
+ XHR: XMLHttpRequest;
+ }
+
+ class ValidationError {
+ key: string;
+ context: any;
+ errorMessage: string;
+ property: IProperty;
+ propertyName: string;
+ validator: Validator;
+ getKey: (validator: Validator, property: string) => string;
+
+ constructor (validator: Validator, context: any, errorMessage: string, key: string);
+ }
+
+ class ValidationOptions {
+ static defaultInstance: ValidationOptions;
+ validateOnAttach: boolean;
+ validateOnPropertyChange: boolean;
+ validateOnQuery: boolean;
+ validateOnSave: boolean;
+
+ constructor (config?: ValidationOptionsConfiguration);
+
+ setAsDefault(): ValidationOptions;
+ using(config: ValidationOptionsConfiguration): ValidationOptions;
+ }
+
+ interface ValidationOptionsConfiguration {
+ validateOnAttach?: boolean;
+ validateOnSave?: boolean;
+ validateOnQuery?: boolean;
+ validateOnPropertyChange?: boolean;
+ }
+
+ class Validator {
+ static messageTemplates: any;
+ context: any;
+ name: string;
+
+ constructor (name: string, validatorFn: ValidatorFunction, context?: any);
+
+ static bool(): Validator;
+ static byte(): Validator;
+ static date(): Validator;
+ static duration(): Validator;
+
+ static guid(): Validator;
+ static int16(): Validator;
+ static int32(): Validator;
+ static int64(): Validator;
+ static maxLength(context: { maxLength: number; }): Validator;
+ static number(): Validator;
+ static required(): Validator;
+ static string(): Validator;
+ static stringLength(context: { maxLength: number; minLength: number; }): Validator;
+
+ static register(validator: Validator);
+ static registerFactory(fn: () => Validator, name: string);
+
+ validate(value: any, context?: any): ValidationError;
+ getMessage(): string;
+ }
+
+ interface ValidatorFunction {
+ (value: any, context: ValidatorFunctionContext): void;
+ }
+
+ interface ValidatorFunctionContext {
+ value: any;
+ validatorName: string;
+ displayName: string;
+ messageTemplate: string;
+ message?: string;
+ }
+
+ var metadataVersion: string;
+ var remoteAccess_odata: string;
+ var remoteAccess_webApi: string;
+ var version: string;
+}
+
+declare module breeze.config {
+ var ajax: string;
+ var dataService: string;
+ var functionRegistry: Object;
+ export function getAdapter(interfaceName: string, adapterName: string): Object;
+ export function getAdapterInstance(interfaceName: string, adapterName: string): Object;
+ export function initializeAdapterInstance(interfaceName: string, adapterName: string, isDefault: boolean): void;
+ export function initializeAdapterInstances(config: Object): void;
+ var interfaceInitialized: Event;
+ var interfaceRegistry: Object;
+ var objectRegistry: Object;
+ export function registerAdapter(interfaceName: string): void;
+ export function registerFunction(fn: Function, fnName: string): void;
+ export function registerType(ctor: Function, typeName: string): void;
+ //static setProperties(config: Object): void; //deprecated
+ var stringifyPad: string;
+ var typeRegistry: Object;
+
+}