diff --git a/breeze/breeze-1.0-tests.ts b/breeze/breeze-1.0-tests.ts
new file mode 100644
index 000000000..6cc115e6f
--- /dev/null
+++ b/breeze/breeze-1.0-tests.ts
@@ -0,0 +1,787 @@
+///
+
+import breeze = module(Breeze);
+import core = module(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 entityManager = 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);
+ 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 hasChangesChanged = 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 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");
+}
+
+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) { });
+}
diff --git a/breeze/breeze-1.0.d.ts b/breeze/breeze-1.0.d.ts
new file mode 100644
index 000000000..8a6458498
--- /dev/null
+++ b/breeze/breeze-1.0.d.ts
@@ -0,0 +1,731 @@
+// Type definitions for Breeze 1.0
+// Project: http://www.breezejs.com/
+// Definitions by: Boris Yankov
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Updated Jan 14 2011 - Jay Traband (www.ideablade.com)
+
+
+declare module BreezeCore {
+
+ interface ErrorCallback {
+ (error: Error): void;
+ }
+
+ interface IEnum {
+ contains(object: any): bool;
+ fromName(name: string): EnumSymbol;
+ getNames(): string[];
+ getSymbols(): EnumSymbol[];
+ }
+
+ class Enum implements IEnum {
+ constructor (name: string, methodObj?: any);
+
+ addSymbol(propertiesObj?: any): EnumSymbol;
+ contains(object: any): bool;
+ fromName(name: string): EnumSymbol;
+ getNames(): string[];
+ getSymbols(): EnumSymbol[];
+ static isSymbol(object: any): bool;
+ 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: bool): void;
+ static enable(eventName: string, target: any, isEnabled: Function): void;
+
+ static isEnabled(eventName: string, target: any): bool;
+ publish(data: any, publishAsync?: bool, errorCallback?: ErrorCallback): void;
+ publishAsync(data: any, errorCallback?: ErrorCallback): void;
+ subscribe(callback?: (data: any) => void ): number;
+ unsubscribe(unsubKey: number): bool;
+ }
+}
+
+declare module Breeze {
+
+ interface Entity {
+ entityAspect: EntityAspect;
+ entityType: EntityType;
+ }
+
+ interface ComplexObject {
+ complexAspect: ComplexAspect;
+ complexType: ComplexType;
+ }
+
+ interface IProperty {
+ name: string;
+ parentEntityType: EntityType;
+ validators: Validator[];
+ isDataProperty: bool;
+ isNavigationProperty: bool;
+ }
+
+ 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: bool;
+ isComplexProperty: bool;
+ isDataProperty: bool;
+ isNavigationProperty: bool;
+ isNullable: bool;
+ isPartOfKey: bool;
+ isUnmapped: bool;
+
+ 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?: bool;
+ isNullable?: bool;
+ isPartOfKey?: bool;
+ isUnmapped?: bool;
+ maxLength?: number;
+ name?: string;
+ nameOnServer?: string;
+ validators?: Validator[];
+ }
+
+ class DataService {
+ adapterName: string;
+ hasServerMetadata: bool;
+ serviceName: string;
+ constructor(config: DataServiceOptions);
+ }
+
+ interface DataServiceOptions {
+ adapterName?: string;
+ hasServerMetadata?: bool;
+ serviceName?: string;
+ }
+
+ class DataTypeSymbol extends BreezeCore.EnumSymbol {
+ defaultValue: any;
+ isNumeric: bool;
+ }
+ 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;
+
+ }
+ declare 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: bool;
+ originalValues: any;
+
+ propertyChanged: PropertyChangedEvent;
+ validationErrorsChanged: ValidationErrorsChangedEvent;
+
+ acceptChanges(): void;
+ addValidationError(validationError: ValidationError): void;
+ clearValidationErrors(): void;
+ getKey(forceRefresh?: bool): 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;
+ validateEntity(): bool;
+
+ validateProperty(property: string, context?: any): bool;
+ validateProperty(property: DataProperty, context?: any): bool;
+ validateProperty(property: NavigationProperty, context?: any): bool;
+ }
+
+ 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): bool;
+ static equals(k1: EntityKey, k2: EntityKey): bool;
+ }
+
+ class EntityManager {
+ dataService: DataService;
+ keyGeneratorCtor: Function;
+ metadataStore: MetadataStore;
+ queryOptions: QueryOptions;
+ saveOptions: SaveOptions;
+ serviceName: string;
+ validationOptions: ValidationOptions;
+
+ entityChanged: EntityChangedEvent;
+ hasChangesChanged: BreezeCore.Event;
+
+ constructor (config?: EntityManagerOptions);
+ constructor (config?: string);
+
+ addEntity(entity: Entity): Entity;
+ attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity;
+ clear(): void;
+ createEmptyCopy(): EntityManager;
+ detachEntity(entity: Entity): bool;
+ createEntity(entityTypeName: string, propertyInitializer: {}): Entity;
+
+ 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?: bool): Entity;
+ fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: bool): Entity;
+ fetchEntityByKey(entityKey: EntityKey): Entity;
+ 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(): bool;
+ hasChanges(entityTypeName: string): bool;
+ hasChanges(entityTypeNames: string[]): bool;
+ hasChanges(entityType: EntityType): bool;
+ hasChanges(entityTypes: EntityType[]): bool;
+
+ static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
+ importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
+
+ rejectChanges(): Entity[];
+ saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): 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: { 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 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?: bool): 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;
+
+ using(obj: EntityManager): 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 BreezeCore.EnumSymbol {
+ isAdded(): bool;
+ isAddedModifiedOrDeleted(): bool;
+ isDeleted(): bool;
+ isDetached(): bool;
+ isModified(): bool;
+ isUnchanged(): bool;
+ isUnchangedOrModified(): bool;
+ }
+ 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?: bool): 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?: bool; usesSql92CompliantStringComparison?: bool; });
+
+ 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?: bool): IStructuralType;
+ getEntityTypes(): IStructuralType[];
+ hasMetadataFor(serviceName: string): bool;
+ static importMetadata(exportedString: string): MetadataStore;
+ importMetadata(exportedString: string): MetadataStore;
+ isEmpty(): bool;
+ registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void;
+ trackUnmappedType(entityCtor: Function, interceptor?: Function);
+ }
+
+ 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: bool;
+ isNavigationProperty: bool;
+ isScalar: bool;
+ name: string;
+ parentEntityType: EntityType;
+ relatedDataProperties: DataProperty[];
+ validators: Validator[];
+
+ constructor (config: NavigationPropertyOptions);
+ }
+
+ interface NavigationPropertyOptions {
+ name?: string;
+ nameOnServer?: string;
+ entityTypeName: string;
+ isScalar?: bool;
+ associationName?: string;
+ foreignKeyNames?: string[];
+ foreignKeyNamesOnServer?: string[];
+ validators?: Validator[];
+ }
+
+ class Predicate {
+ constructor (property: string, operator: string, value: any, valueIsLiteral?: bool);
+ constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: bool);
+
+ and: PredicateMethod;
+ static and: PredicateMethod;
+
+ static create: PredicateMethod;
+
+ static isPredicate(o: any): bool;
+
+ 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?: bool): Predicate;
+ (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: bool): 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: bool;
+ static defaultInstance: SaveOptions;
+
+ constructor (config?: { allowConcurrentSaves?: bool; });
+
+ 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: bool;
+ validateOnPropertyChange: bool;
+ validateOnQuery: bool;
+ validateOnSave: bool;
+
+ constructor (config?: ValidationOptionsConfiguration);
+
+ setAsDefault(): ValidationOptions;
+ using(config: ValidationOptionsConfiguration): ValidationOptions;
+ }
+
+ interface ValidationOptionsConfiguration {
+ validateOnAttach?: bool;
+ validateOnSave?: bool;
+ validateOnQuery?: bool;
+ validateOnPropertyChange?: bool;
+ }
+
+ 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;
+ }
+}
diff --git a/breeze/breeze-tests.ts b/breeze/breeze-tests.ts
index 09dd6a4a3..427547574 100644
--- a/breeze/breeze-tests.ts
+++ b/breeze/breeze-tests.ts
@@ -1,7 +1,6 @@
///
-import breeze = module(Breeze);
-import core = module(BreezeCore);
+import core = module(breezeCore);
function test_dataType() {
var typ = breeze.DataType.DateTime;
@@ -9,9 +8,10 @@ function test_dataType() {
var isNumber = typ.isNumeric;
var dv = typ.defaultValue;
var symbs = breeze.DataType.getSymbols();
- var x = typ.parentEnum === breeze.DataType;
+ var x = typ.parentEnum === breeze.DataType;
var isFalse = breeze.DataType.contains(breeze.DataType.Double);
var dt = breeze.DataType.fromName("Decimal");
+
}
function test_dataProperty() {
@@ -33,6 +33,7 @@ function test_dataService() {
var em = new breeze.EntityManager({
dataService: ds
});
+
}
function test_entityAspect() {
@@ -125,12 +126,13 @@ function test_metadataStore() {
function test_entityManager() {
var entityManager = new breeze.EntityManager("api/NorthwindIBModel");
- var entityManager = new breeze.EntityManager({ serviceName: "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
@@ -152,6 +154,10 @@ function test_entityManager() {
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();
@@ -239,7 +245,8 @@ function test_entityManager() {
if (em1.hasChanges(custType)) { }
var custType = em1.metadataStore.getEntityType("Customer");
var orderType = em1.metadataStore.getEntityType("Order");
- if (em1.hasChanges([custType, orderType])) { }
+ if (em1.hasChanges([custType, orderType])) { };
+
var bundle = em1.exportEntities();
window.localStorage.setItem("myEntityManager", bundle);
var bundleFromStorage = window.localStorage.getItem("myEntityManager");
@@ -280,7 +287,7 @@ function test_entityManager() {
});
var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
em.hasChangesChanged.subscribe(function (args) {
- var hasChangesChanged = args.hasChanges;
+ var hasChanges = args.hasChanges;
var entityManager = args.entityManager;
});
}
@@ -377,6 +384,8 @@ function test_entityQuery() {
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")
@@ -393,6 +402,7 @@ function test_entityQuery() {
.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() {
@@ -784,4 +794,4 @@ function test_demo() {
.from("Employees");
manager.executeQuery(query).then(function (data) { });
-}
+}
\ No newline at end of file
diff --git a/breeze/breeze.d.ts b/breeze/breeze.d.ts
index 8a6458498..3f4532975 100644
--- a/breeze/breeze.d.ts
+++ b/breeze/breeze.d.ts
@@ -1,12 +1,13 @@
-// Type definitions for Breeze 1.0
+// Type definitions for Breeze 1.2.7
// Project: http://www.breezejs.com/
-// Definitions by: Boris Yankov
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
+// 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)
-declare module BreezeCore {
+declare module breezeCore {
interface ErrorCallback {
(error: Error): void;
@@ -53,7 +54,7 @@ declare module BreezeCore {
}
}
-declare module Breeze {
+declare module breeze {
interface Entity {
entityAspect: EntityAspect;
@@ -151,6 +152,7 @@ declare module Breeze {
adapterName: string;
hasServerMetadata: bool;
serviceName: string;
+ jsonResultsAdapter: JsonResultsAdapter;
constructor(config: DataServiceOptions);
}
@@ -158,13 +160,38 @@ declare module Breeze {
adapterName?: string;
hasServerMetadata?: bool;
serviceName?: string;
+ jsonResultsAdapter?: JsonResultsAdapter;
}
- class DataTypeSymbol extends BreezeCore.EnumSymbol {
+ class JsonResultsAdapter {
+ name: string;
+ extractResults: (data: {}) => {};
+ visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: bool; };
+ constructor(config: {
+ name: string;
+ extractResults?: (data: {}) => {};
+ visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: bool; };
+ });
+ }
+
+ 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: bool;
}
- interface DataType extends BreezeCore.IEnum {
+ interface DataType extends breezeCore.IEnum {
Binary: DataTypeSymbol;
Boolean: DataTypeSymbol;
Byte: DataTypeSymbol;
@@ -185,9 +212,9 @@ declare module Breeze {
}
declare var DataType: DataType;
- class EntityActionSymbol extends BreezeCore.EnumSymbol {
+ class EntityActionSymbol extends breezeCore.EnumSymbol {
}
- interface EntityAction extends BreezeCore.IEnum {
+ interface EntityAction extends breezeCore.IEnum {
AcceptChanges: EntityActionSymbol;
Attach: EntityActionSymbol;
AttachOnImport: EntityActionSymbol;
@@ -248,7 +275,7 @@ declare module Breeze {
newValue: any;
}
- class PropertyChangedEvent extends BreezeCore.Event {
+ class PropertyChangedEvent extends breezeCore.Event {
subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number;
}
@@ -258,7 +285,7 @@ declare module Breeze {
removed: ValidationError[];
}
- class ValidationErrorsChangedEvent extends BreezeCore.Event {
+ class ValidationErrorsChangedEvent extends breezeCore.Event {
subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number;
}
@@ -280,7 +307,7 @@ declare module Breeze {
validationOptions: ValidationOptions;
entityChanged: EntityChangedEvent;
- hasChangesChanged: BreezeCore.Event;
+ hasChangesChanged: HasChangesChangedEvent;
constructor (config?: EntityManagerOptions);
constructor (config?: string);
@@ -289,18 +316,17 @@ declare module Breeze {
attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity;
clear(): void;
createEmptyCopy(): EntityManager;
+ createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol) : Entity;
detachEntity(entity: Entity): bool;
- createEntity(entityTypeName: string, propertyInitializer: {}): Entity;
-
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?: bool): Entity;
- fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: bool): Entity;
- fetchEntityByKey(entityKey: EntityKey): Entity;
- fetchMetadata(callback?: (schema: any) => void , errorCallback?: BreezeCore.ErrorCallback): Promise;
+ fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: bool): Promise;
+ fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: bool): Promise;
+ fetchEntityByKey(entityKey: EntityKey): Promise;
+ fetchMetadata(callback?: (schema: any) => void , errorCallback?: breezeCore.ErrorCallback): Promise;
generateTempKeyValue(entity: Entity): any;
getChanges(): Entity[];
getChanges(entityTypeName: string): Entity[];
@@ -377,10 +403,19 @@ declare module Breeze {
args: Object;
}
- class EntityChangedEvent extends BreezeCore.Event {
+ class EntityChangedEvent extends breezeCore.Event {
subscribe(callback?: (data: EntityChangedEventArgs) => void ): number;
}
+ class HasChangesChangedEventArgs {
+ entityManager: EntityManager;
+ hasChanges: bool;
+ }
+
+ class HasChangesChangedEvent extends breezeCore.Event {
+ subscribe(callback?: (data: HasChangesChangedEventArgs) => void ): number;
+ }
+
class EntityQuery {
entityManager: EntityManager;
orderByClause: OrderByClause;
@@ -413,10 +448,13 @@ declare module Breeze {
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: FetchStrategySymbol): EntityQuery;
+ using(obj: JsonResultsAdapter): EntityQuery;
where(predicate: Predicate): EntityQuery;
where(property: string, operator: string, value: any): EntityQuery;
@@ -428,7 +466,7 @@ declare module Breeze {
interface OrderByClause {
}
- class EntityStateSymbol extends BreezeCore.EnumSymbol {
+ class EntityStateSymbol extends breezeCore.EnumSymbol {
isAdded(): bool;
isAddedModifiedOrDeleted(): bool;
isDeleted(): bool;
@@ -437,7 +475,7 @@ declare module Breeze {
isUnchanged(): bool;
isUnchangedOrModified(): bool;
}
- interface EntityState extends BreezeCore.IEnum {
+ interface EntityState extends breezeCore.IEnum {
Added: EntityStateSymbol;
Deleted: EntityStateSymbol;
Detached: EntityStateSymbol;
@@ -490,17 +528,17 @@ declare module Breeze {
defaultResourceName?: string;
}
- class FetchStrategySymbol extends BreezeCore.EnumSymbol {
+ class FetchStrategySymbol extends breezeCore.EnumSymbol {
}
- interface FetchStrategy extends BreezeCore.IEnum {
+ interface FetchStrategy extends breezeCore.IEnum {
FromLocalCache: FetchStrategySymbol;
FromServer: FetchStrategySymbol;
}
var FetchStrategy: FetchStrategy;
- class FilterQueryOpSymbol extends BreezeCore.EnumSymbol {
+ class FilterQueryOpSymbol extends breezeCore.EnumSymbol {
}
- interface FilterQueryOp extends BreezeCore.IEnum {
+ interface FilterQueryOp extends breezeCore.IEnum {
Contains: FilterQueryOpSymbol;
EndsWith: FilterQueryOpSymbol;
Equals: FilterQueryOpSymbol;
@@ -522,9 +560,9 @@ declare module Breeze {
setAsDefault(): void;
}
- class MergeStrategySymbol extends BreezeCore.EnumSymbol {
+ class MergeStrategySymbol extends breezeCore.EnumSymbol {
}
- interface MergeStrategy extends BreezeCore.IEnum {
+ interface MergeStrategy extends breezeCore.IEnum {
OverwriteChanges: MergeStrategySymbol;
PreserveChanges: MergeStrategySymbol;
}
@@ -537,8 +575,8 @@ declare module Breeze {
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;
+ 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?: bool): IStructuralType;
getEntityTypes(): IStructuralType[];
@@ -728,4 +766,4 @@ declare module Breeze {
messageTemplate: string;
message?: string;
}
-}
+}
\ No newline at end of file