From 71824062246817eaa7b8d470b206b75e21c865f6 Mon Sep 17 00:00:00 2001 From: basarat Date: Mon, 26 Aug 2013 21:09:46 +1000 Subject: [PATCH] breezejs : Update to 1.4.1 iceboxing old version to pull in new version closes PR#858 --- breeze/breeze-1.2-tests.ts | 797 +++++++++++++++++ breeze/breeze-1.2.d.ts | 779 +++++++++++++++++ breeze/breeze-tests.ts | 1673 ++++++++++++++++++----------------- breeze/breeze.d.ts | 1678 +++++++++++++++++++----------------- 4 files changed, 3351 insertions(+), 1576 deletions(-) create mode 100644 breeze/breeze-1.2-tests.ts create mode 100644 breeze/breeze-1.2.d.ts 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; + +}