From e2567c2be0d458be5d4785ac9e4be904a86f39dc Mon Sep 17 00:00:00 2001 From: Diullei Gomes Date: Fri, 29 Mar 2013 11:36:15 -0300 Subject: [PATCH] breeze updated - 1.2.7 --- breeze/breeze-1.0-tests.ts | 787 +++++++++++++++++++++++++++++++++++++ breeze/breeze-1.0.d.ts | 731 ++++++++++++++++++++++++++++++++++ breeze/breeze-tests.ts | 24 +- breeze/breeze.d.ts | 102 +++-- 4 files changed, 1605 insertions(+), 39 deletions(-) create mode 100644 breeze/breeze-1.0-tests.ts create mode 100644 breeze/breeze-1.0.d.ts diff --git a/breeze/breeze-1.0-tests.ts b/breeze/breeze-1.0-tests.ts new file mode 100644 index 000000000..6cc115e6f --- /dev/null +++ b/breeze/breeze-1.0-tests.ts @@ -0,0 +1,787 @@ +/// + +import breeze = module(Breeze); +import core = module(BreezeCore); + +function test_dataType() { + var typ = breeze.DataType.DateTime; + var nm = typ.getName(); + var isNumber = typ.isNumeric; + var dv = typ.defaultValue; + var symbs = breeze.DataType.getSymbols(); + var x = typ.parentEnum === breeze.DataType; + var isFalse = breeze.DataType.contains(breeze.DataType.Double); + var dt = breeze.DataType.fromName("Decimal"); +} + +function test_dataProperty() { + var lastNameProp = new breeze.DataProperty({ + name: "lastName", + dataType: breeze.DataType.String, + isNullable: true, + maxLength: 20 + }); + var personEntityType: breeze.EntityType; + personEntityType.addProperty(lastNameProp); +} + +function test_dataService() { + var ds = new breeze.DataService({ + serviceName: "api/NorthwindIBModel", + hasServerMetadata: true + }); + var em = new breeze.EntityManager({ + dataService: ds + }); +} + +function test_entityAspect() { + var order: breeze.Entity; + order.entityAspect.acceptChanges(); + var entityKey = order.entityAspect.getKey(); + var valErrors = order.entityAspect.getValidationErrors(); + var orderDateErrors = order.entityAspect.getValidationErrors("OrderDate"); + var orderDateProperty = order.entityType.getProperty("OrderDate"); + var orderDateErrors = order.entityAspect.getValidationErrors(orderDateProperty); + order.entityAspect.loadNavigationProperty("Orders").then(function (data) { + var orders = data.results; + }).fail(function (exception) { }); + order.entityAspect.rejectChanges(); + order.entityAspect.setDeleted(); + order.entityAspect.setModified(); + order.entityAspect.setUnchanged(); + var isOk = order.entityAspect.validateEntity(); + if (!isOk) { + var errors = order.entityAspect.getValidationErrors(); + } + var isOk = order.entityAspect.validateProperty("Order"); + var orderDateProperty = order.entityType.getProperty("OrderDate"); + //var isOk = order.entityAspect.validateProperty(OrderDateProperty); + order.entityAspect.propertyChanged.subscribe(function (propertyChangedArgs) { + var entity = propertyChangedArgs.entity; + var propertyNameChanged = propertyChangedArgs.propertyName; + var oldValue = propertyChangedArgs.oldValue; + var newValue = propertyChangedArgs.newValue; + }); + order.entityAspect.validationErrorsChanged.subscribe(function (validationChangeArgs) { + var entity = validationChangeArgs.entity; + var errorsAdded = validationChangeArgs.added; + var errorsCleared = validationChangeArgs.removed; + }); + +} + +function test_entityKey() { + var em1: breeze.EntityManager; + var employee1: breeze.Entity; + var empType = em1.metadataStore.getEntityType("Employee"); + var entityKey = new breeze.EntityKey( empType, 1); + var empKey = employee1.entityAspect.getKey(); + var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory"); + var empTerrKey = new breeze.EntityKey( empTerrType, [1, 77]); + var empType = em1.metadataStore.getEntityType("Employee"); + var empKey1 = new breeze.EntityKey( empType, 1); + var empKey2 = employee1.entityAspect.getKey(); + if (empKey1.equals(empKey2)) { } + if (breeze.EntityKey.equals(empKey1, empKey2)) { } +} + +function test_metadataStore() { + var ms = new breeze.MetadataStore(); + var entityManager = new breeze.EntityManager({ + serviceName: "api/NorthwindIBModel", + metadataStore: ms + }); + var em1: breeze.EntityManager; + em1.setProperties({ metadataStore: ms }); + var metadataAsString = ms.exportMetadata(); + window.localStorage.setItem("metadata", metadataAsString); + var metadataFromStorage = window.localStorage.getItem("metadata"); + var newMetadataStore = new breeze.MetadataStore(); + newMetadataStore.importMetadata(metadataFromStorage); + var ms = new breeze.MetadataStore(); + ms.fetchMetadata("api/NorthwindIBModel") + .then(function (rawMetadata) { }) + .fail(function (exception) { }); + var odType = em1.metadataStore.getEntityType("OrderDetail"); + var badType = em1.metadataStore.getEntityType("Foo", false); + var allTypes = em1.metadataStore.getEntityTypes(); + if (!em1.metadataStore.hasMetadataFor("api/NorthwindIBModel")) { } + var metadataAsString = ms.exportMetadata(); + window.localStorage.setItem("metadata", metadataAsString); + var metadataFromStorage = window.localStorage.getItem("metadata"); + var newMetadataStore = breeze.MetadataStore.importMetadata(metadataFromStorage); + var metadataAsString = ms.exportMetadata(); + window.localStorage.setItem("metadata", metadataAsString); + var metadataFromStorage = window.localStorage.getItem("metadata"); + var newMetadataStore = new breeze.MetadataStore(); + newMetadataStore.importMetadata(metadataFromStorage); + if (em1.metadataStore.isEmpty()) { } + var Customer = function () { + this.miscData = "asdf"; + } + em1.metadataStore.registerEntityTypeCtor("Customer", Customer); +} + +function test_entityManager() { + var entityManager = new breeze.EntityManager("api/NorthwindIBModel"); + var entityManager = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); + var metadataStore = new breeze.MetadataStore(); + var entityManager = new breeze.EntityManager({ + serviceName: "api/NorthwindIBModel", + metadataStore: metadataStore + }); + return new breeze.QueryOptions({ + mergeStrategy: null, + fetchStrategy: this.fetchStrategy + }); + var queryOptions = new breeze.QueryOptions({ + mergeStrategy: breeze.MergeStrategy.OverwriteChanges, + fetchStrategy: breeze.FetchStrategy.FromServer + }); + var validationOptions = new breeze.ValidationOptions({ + validateOnAttach: true, + validateOnSave: true, + validateOnQuery: false + }); + var entityManager = new breeze.EntityManager({ + serviceName: "api/NorthwindIBModel", + queryOptions: queryOptions, + validationOptions: validationOptions + }); + var custType = em1.metadataStore.getEntityType("Customer"); + var cust1 = custType.createEntity(); + em1.addEntity(cust1); + em1.attachEntity(cust1, breeze.EntityState.Added); + em1.clear(); + var em2 = em1.createEmptyCopy(); + em1.detachEntity(cust1); + var serviceName: string; + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders"); + em.executeQuery(query) + .then(function (data) { + var orders = data.results; + }).fail(function (err) { + }); + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders"); + em.executeQuery(query, + function (data) { + var orders = data.results; + }, + function (err) { + }); + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders").using(em); + query.execute() + .then(function (data) { + var orders = data.results; + }).fail(function (err) { + }); + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders"); + var orders = em.executeQueryLocally(query); + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders").using(breeze.FetchStrategy.FromLocalCache); + em.executeQuery(query) + .then(function (data) { + var orders = data.results; + }).fail(function (err) { + }); + var bundle = em1.exportEntities(); + window.localStorage.setItem("myEntityManager", bundle); + var bundleFromStorage = window.localStorage.getItem("myEntityManager"); + var em2 = new breeze.EntityManager({ + serviceName: em1.serviceName, + metadataStore: em1.metadataStore + }); + em2.importEntities(bundleFromStorage); + var entitiesToExport: breeze.Entity[]; + var bundle = em1.exportEntities(entitiesToExport); + em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges }); + var em1 = new breeze.EntityManager("api/NorthwindIBModel"); + em1.fetchMetadata() + .then(function () { + var metadataStore = em1.metadataStore; + }) + .fail(function (exception) { + }); + var employeeType = em1.metadataStore.getEntityType("Employee"); + var employeeKey = new breeze.EntityKey( employeeType, 1); + var employee = em1.fetchEntityByKey(employeeKey); + var emp2 = em1.fetchEntityByKey("Employee", 6); + var emp3 = em1.fetchEntityByKey("Entityee", [6]); + var custType = em1.metadataStore.getEntityType("Customer"); + var custumer = custType.createEntity(); + var customerId = em.generateTempKeyValue(custumer); + em1.saveChanges() + .then(function (data) { + var sameCust1 = data.results[0]; + }); + var changedEntities = em1.getChanges(); + var custType = em1.metadataStore.getEntityType("Customer"); + var changedCustomers = em1.getChanges(custType); + var custType = em1.metadataStore.getEntityType("Customer"); + var orderType = em1.metadataStore.getEntityType("Order"); + var changedCustomersAndOrders = em1.getChanges([custType, orderType]); + var entities = em1.getEntities(); + var custType = em1.metadataStore.getEntityType("Customer"); + var customers = em1.getEntities(custType); + var custType = em1.metadataStore.getEntityType("Customer"); + var orderType = em1.metadataStore.getEntityType("Order"); + var customersAndOrders = em1.getChanges([custType, orderType]); + var custType = em1.metadataStore.getEntityType("Customer"); + var orderType = em1.metadataStore.getEntityType("Order"); + var addedCustomersAndOrders = em1.getEntities([custType, orderType], breeze.EntityState.Added); + if (em1.hasChanges()) { } + var custType = em1.metadataStore.getEntityType("Customer"); + if (em1.hasChanges(custType)) { } + var custType = em1.metadataStore.getEntityType("Customer"); + var orderType = em1.metadataStore.getEntityType("Order"); + if (em1.hasChanges([custType, orderType])) { } + var bundle = em1.exportEntities(); + window.localStorage.setItem("myEntityManager", bundle); + var bundleFromStorage = window.localStorage.getItem("myEntityManager"); + var em2 = breeze.EntityManager.importEntities(bundleFromStorage); + var bundle = em1.exportEntities(); + var em2 = new breeze.EntityManager({ + serviceName: em1.serviceName, + metadataStore: em1.metadataStore + }); + em2.importEntities(bundle); + var bundle = em1.exportEntities(); + em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges }); + em.saveChanges().then(function (saveResult) { + var savedEntities = saveResult.entities; + var keyMappings = saveResult.keyMappings; + }).fail(function (e) { + }); + var saveOptions = new breeze.SaveOptions({ allowConcurrentSaves: true }); + var entitiesToSave: breeze.Entity[]; + em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult) { + var savedEntities = saveResult.entities; + var keyMappings = saveResult.keyMappings; + }).fail(function (e) { + }); + em.saveChanges(entitiesToSave, null, + function (saveResult) { + var savedEntities = saveResult.entities; + var keyMappings = saveResult.keyMappings; + }, function (e) { } + ); + em1.setProperties({ + serviceName: "api/foo", + }); + var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); + em.entityChanged.subscribe(function (changeArgs) { + var action = changeArgs.entityAction; + var entity = changeArgs.entity; + }); + var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); + em.hasChangesChanged.subscribe(function (args) { + var hasChangesChanged = args.hasChanges; + var entityManager = args.entityManager; + }); +} + +function test_entityQuery() { + var query = new breeze.EntityQuery("Customers"); + var query = new breeze.EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .orderBy("Region"); + var serviceName: string; + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders").using(em); + query.execute() + .then(function (data) { }) + .fail(function (err) { }); + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders").using(em); + query.execute( + function (data) { + var orders = data.results; + }, + function (err) { }); + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders"); + em.executeQuery(query) + .then(function (data) { + var orders = data.results; + }).fail(function (err) { + }); + var query = new breeze.EntityQuery("Orders").using(em); + var orders = query.executeLocally(); + var query = new breeze.EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .expand("Orders"); + var query = new breeze.EntityQuery("Orders") + .expand("Customer, Employee"); + var query = new breeze.EntityQuery("Orders") + .expand("Customer, OrderDetails, OrderDetails.Product"); + var query = breeze.EntityQuery.from("Customers"); + var query = new breeze.EntityQuery("Customers"); + var query = new breeze.EntityQuery().from("Customers"); + var customer: breeze.Entity; + var customers: breeze.Entity[]; + var customersQuery = breeze.EntityQuery.fromEntities(customers); + var customersQuery = breeze.EntityQuery.fromEntities(customers) + .where("Region", breeze.FilterQueryOp.NotEquals, null); + var customerQuery = breeze.EntityQuery.fromEntities(customer); + var metadataStore: breeze.MetadataStore; + var empType = metadataStore.getEntityType("Employee"); + var entityKey = new breeze.EntityKey( empType, 1); + var query = breeze.EntityQuery.fromEntityKey(entityKey); + var employee: breeze.Entity; + var entityKey = employee.entityAspect.getKey(); + var query = breeze.EntityQuery.fromEntityKey(entityKey); + var ordersNavProp = employee.entityType.getProperty("Orders"); + var query = breeze.EntityQuery.fromEntityNavigation(employee, ordersNavProp); + var query = new breeze.EntityQuery("Customers") + .orderBy("CompanyName"); + var query = new breeze.EntityQuery("Customers") + .orderBy("Region, CompanyName"); + var query = new breeze.EntityQuery("Products") + .orderBy("Category.CategoryName"); + var query = new breeze.EntityQuery("Customers") + .orderBy("CompanyName desc"); + var query = new breeze.EntityQuery("Customers") + .orderBy("Region desc, CompanyName desc"); + var query = new breeze.EntityQuery("Customers") + .orderByDesc("CompanyName"); + var query = new breeze.EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .select("CompanyName"); + var query = new breeze.EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .select("Orders"); + var query = new breeze.EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .select("CompanyName, Orders"); + var query = new breeze.EntityQuery("Orders") + .where("Customer.CompanyName", "startsWith", "C") + .select("Customer.CompanyName, Customer, OrderDate"); + var query = new breeze.EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .skip(5); + var query = new breeze.EntityQuery("Customers") + .take(5); + var query = new breeze.EntityQuery("Customers") + .top(5); + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders") + .using(em); + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders") + .using(breeze.MergeStrategy.PreserveChanges); + var em = new breeze.EntityManager(serviceName); + var query = new breeze.EntityQuery("Orders") + .using(breeze.FetchStrategy.FromLocalCache); + var query = new breeze.EntityQuery("Customers") + .where("CompanyName", "startsWith", "C"); + var query = new breeze.EntityQuery("Customers") + .where("CompanyName", breeze.FilterQueryOp.StartsWith, "C"); + var pred = new breeze.Predicate("CompanyName", breeze.FilterQueryOp.StartsWith, "C"); + var query = new breeze.EntityQuery("Customers") + .where(pred); + var pred = breeze.Predicate.create("CompanyName", "startswith", "C").and("Region", breeze.FilterQueryOp.Equals, null); + var query = new breeze.EntityQuery("Customers") + .where(pred); + var query = new breeze.EntityQuery("Products") + .where("Category.CategoryName", "startswith", "S"); + var query = new breeze.EntityQuery("Customers") + .where("toLower(CompanyName)", "startsWith", "c"); + var query = new breeze.EntityQuery("Customers") + .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM"); +} + +function test_entityState() { + var anEntity: breeze.Entity; + var es = anEntity.entityAspect.entityState; + return es.isAdded(); + return es === breeze.EntityState.Added; + var es = anEntity.entityAspect.entityState; + return es.isAddedModifiedOrDeleted(); + return es === breeze.EntityState.Added || es === breeze.EntityState.Modified || es === breeze.EntityState.Deleted; + var es = anEntity.entityAspect.entityState; + return es.isDeleted(); + return es === breeze.EntityState.Deleted; + var es = anEntity.entityAspect.entityState; + return es.isDetached(); + return es === breeze.EntityState.Detached; + var es = anEntity.entityAspect.entityState; + return es.isModified(); + return es === breeze.EntityState.Modified; + var es = anEntity.entityAspect.entityState; + return es.isUnchanged(); + return es === breeze.EntityState.Unchanged; + var es = anEntity.entityAspect.entityState; + return es.isUnchangedOrModified(); + + return es === breeze.EntityState.Unchanged || es === breeze.EntityState.Modified; +} + +function test_entityType() { + var myMetadataStore: breeze.MetadataStore; + var myEntityType: breeze.EntityType; + var dataProperty1, dataProperty2, navigationProperty1: breeze.DataProperty; + var em1: breeze.EntityManager; + var entityManager = new breeze.EntityType({ + metadataStore: myMetadataStore, + serviceName: "api/NorthwindIBModel", + name: "person", + namespace: "myAppNamespace" + }); + myEntityType.addProperty(dataProperty1); + myEntityType.addProperty(dataProperty2); + myEntityType.addProperty(navigationProperty1); + var custType = em1.metadataStore.getEntityType("Customer"); + var countryProp = custType.getProperty("Country"); + var valFn = function (v) { + if (v == null) return true; + return (v.substring(0,2) === "US"); + }; + var countryValidator = new breeze.Validator("countryIsUS", valFn, + { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" }); + custType.addValidator(countryValidator, countryProp); + countryProp.validators.push(countryValidator); + var someEntityLevelValidator: breeze.Validator; + custType.addValidator(someEntityLevelValidator); + custType.validators.push(someEntityLevelValidator); + var custType = em1.metadataStore.getEntityType("Customer"); + var cust1 = custType.createEntity(); + em1.addEntity(cust1); + var custType = em1.metadataStore.getEntityType("Customer"); + var customerNameDataProp = custType.getDataProperty("CustomerName"); + var custType = em1.metadataStore.getEntityType("Customer"); + var customerOrdersNavProp = custType.getDataProperty("Orders"); + var custType = em1.metadataStore.getEntityType("Customer"); + var arrayOfProps = custType.getProperties(); + var custType = em1.metadataStore.getEntityType("Customer"); + var companyNameProp = custType.getProperty("CompanyName"); + var orderDetailType = em1.metadataStore.getEntityType("OrderDetail"); + var companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName"); + var custType = em1.metadataStore.getEntityType("Customer"); + var arrayOfPropNames = custType.getPropertyNames(); + var custType = em1.metadataStore.getEntityType("Customer"); + custType.setProperties({ + autoGeneratedKeyType: breeze.AutoGeneratedKeyType.Identity, + defaultResourceName: "CustomersAndIncludedOrders" + }); +} + +//function test_enum() { +// var prototype = { +// nextDay: function () { +// var nextIndex = (this.dayIndex + 1) % 7; +// return DayOfWeek.getSymbols()[nextIndex]; +// } +// }; +// var DayOfWeek = new core.Enum("DayOfWeek", prototype); +// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 }); +// var symbol = DayOfWeek.Friday; +// if (DayOfWeek.contains(symbol)) { } +// var dayOfWeek = DayOfWeek.from("Thursday"); +// var symbols = DayOfWeek.getNames(); +// var symbols = DayOfWeek.getSymbols(); +// if (core.Enum.isSymbol(DayOfWeek.Wednesday)) { }; +// DayOfWeek.seal(); +// var name = DayOfWeek.Monday.getName(); +// var name = DayOfWeek.Monday.toString(); + + +// var prototype = { +// nextDay: function () { +// var nextIndex = (this.dayIndex + 1) % 7; +// return DayOfWeek.getSymbols()[nextIndex]; +// } +// }; +// var DayOfWeek = new core.Enum("DayOfWeek", prototype); +// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 }); +// DayOfWeek.Tuesday = DayOfWeek.addSymbol({ dayIndex: 1 }); +// DayOfWeek.Wednesday = DayOfWeek.addSymbol({ dayIndex: 2 }); +// DayOfWeek.Thursday = DayOfWeek.addSymbol({ dayIndex: 3 }); +// DayOfWeek.Friday = DayOfWeek.addSymbol({ dayIndex: 4 }); +// DayOfWeek.Saturday = DayOfWeek.addSymbol({ dayIndex: 5, isWeekend: true }); +// DayOfWeek.Sunday = DayOfWeek.addSymbol({ dayIndex: 6, isWeekend: true }); +// DayOfWeek.seal(); +// DayOfWeek.Monday.nextDay() === DayOfWeek.Tuesday; +// DayOfWeek.Sunday.nextDay() === DayOfWeek.Monday; +// DayOfWeek.Tuesday.isWeekend === undefined; +// DayOfWeek.Saturday.isWeekend == true; +// DayOfWeek instanceof core.Enum; +// core.Enum.isSymbol(DayOfWeek.Wednesday); +// DayOfWeek.contains(DayOfWeek.Thursday); +// DayOfWeek.Tuesday.parentEnum == DayOfWeek; +// DayOfWeek.getSymbols().length === 7; +// DayOfWeek.Friday.toString() === "Friday"; +//} + +function test_event() { + var myEntityManager: breeze.EntityManager; + var myEntity, person: breeze.Entity; + var salaryEvent = new core.Event("salaryEvent", person); + core.Event.enable("propertyChanged", myEntityManager, false); + core.Event.enable("propertyChanged", myEntityManager, true); + core.Event.enable("propertyChanged", myEntity.entityAspect, false); + core.Event.enable("propertyChanged", myEntity.entityAspect, null); + core.Event.enable("validationErrorsChanged", myEntityManager, function (em) { + return em.customTag === "blue"; + }); + core.Event.isEnabled("propertyChanged", myEntityManager); + salaryEvent.publish({ eventType: "payRaise", amount: 100 }); + salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true); + salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true, function (error) { }); + salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 }); + salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 }, function (error) { }); + salaryEvent.subscribe(function (eventArgs) { + if (eventArgs.eventType === "payRaise") { } + }); + var order: breeze.Entity; + order.entityAspect.propertyChanged.subscribe(function (pcEvent) { + if (pcEvent.propertyName === "OrderDate") { } + }); + var token = order.entityAspect.propertyChanged.subscribe(function (pcEvent) { }); + order.entityAspect.propertyChanged.unsubscribe(token); +} + +function test_localQueryComparisonOptions() { + var lqco = new breeze.LocalQueryComparisonOptions({ + name: "caseSensitive-nonSQL", + isCaseSensitive: true, + usesSql92CompliantStringComparison: false + }); + lqco.setAsDefault(); + var ms = new breeze.MetadataStore({ localQueryComparisonOptions: lqco }); + var em = new breeze.EntityManager({ metadataStore: ms }); + var lqco = new breeze.LocalQueryComparisonOptions({ + isCaseSensitive: false, + usesSql92CompliantStringComparison: true + }); + lqco.setAsDefault(); +} + +function test_namingConventions() { + var namingConv = new breeze.NamingConvention({ + serverPropertyNameToClient: function (serverPropertyName) { + return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1); + }, + clientPropertyNameToServer: function (clientPropertyName) { + return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1); + } + }); + var nc = new breeze.NamingConvention({ + serverPropertyNameToClient: function (x) { + return "xxx"; + } + }); + var ms = new breeze.MetadataStore({ namingConvention: namingConv }); + var em = new breeze.EntityManager({ metadataStore: ms }); + var namingConv = new breeze.NamingConvention({ + serverPropertyNameToClient: function (serverPropertyName) { + return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1); + }, + clientPropertyNameToServer: function (clientPropertyName) { + return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1); + } + }); + namingConv.setAsDefault(); +} + +function test_navigationProperty() { + var homeAddressProp = new breeze.NavigationProperty({ + name: "homeAddress", + entityTypeName: "Address:#myNamespace", + isScalar: true, + associationName: "address_person", + foreignKeyNames: ["homeAddressId"] + }); + var homeAddressIdProp = new breeze.DataProperty({ + name: "homeAddressId", + dataType: breeze.DataType.Int32 + }); + var personEntityType: breeze.EntityType; + personEntityType.addProperty(homeAddressProp); + personEntityType.addProperty(homeAddressIdProp); +} + +function test_predicate() { + var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B"); + var p1a = breeze.Predicate.create("CompanyName", "==", "City"); + var p2a = p1a.and(p1a.not()); + var query = new breeze.EntityQuery("Customers").where(p1); + var p2 = new breeze.Predicate("Region", breeze.FilterQueryOp.Equals, null); + var query = new breeze.EntityQuery("Customers").where(p2); + var dt = new Date(88, 9, 12); + var p1 = breeze.Predicate.create("OrderDate", "ne", dt); + var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); + var p3 = breeze.Predicate.create("Freight", ">", 100); + var newPred = p1.and(p2, p3); + var preds = [p2, p3]; + var newPred = p1.and(preds); + var p4 = breeze.Predicate.create("ShipCity", "startswith", "F") + .and("Size", "gt", 2000); + var dt = new Date(88, 9, 12); + var p1 = breeze.Predicate.create("OrderDate", "ne", dt); + var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); + var p3 = breeze.Predicate.create("Freight", ">", 100); + var newPred = breeze.Predicate.and(p1, p2, p3); + var preds = [p1, p2, p3]; + var newPred = breeze.Predicate.and(preds); + var p1 = breeze.Predicate.create("Freight", "gt", 100); + var predArgs: any[] = ["Freight", "gt", 100]; + var p1 = breeze.Predicate.create(predArgs); + var p1 = new breeze.Predicate("Freight", "gt", 100); + var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B"); + if (breeze.Predicate.isPredicate(p1)) { } + var p1 = breeze.Predicate.create("Freight", "gt", 100); + var not_p1 = breeze.Predicate.not(p1); + var not_p1 = p1.not(); + var not_p1 = breeze.Predicate.create("Freight", "le", 100); + var dt = new Date(88, 9, 12); + var p1 = breeze.Predicate.create("OrderDate", "ne", dt); + var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); + var p3 = breeze.Predicate.create("Freight", ">", 100); + var newPred = breeze.Predicate.or(p1, p2, p3); + var preds = [p1, p2, p3]; + var newPred = breeze.Predicate.or(preds); + var dt = new Date(88, 9, 12); + var p1 = breeze.Predicate.create("OrderDate", "ne", dt); + var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); + var p3 = breeze.Predicate.create("Freight", ">", 100); + var newPred = p1.and(p2, p3); + var preds = [p2, p3]; + var newPred = p1.and(preds); + var p4 = breeze.Predicate.create("ShipCity", "startswith", "F") + .or("Size", "gt", 2000); +} + +function test_queryOptions() { + var em1: breeze.EntityManager; + var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges }); + em1.setProperties({ queryOptions: newQo }); + var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges }); + newQo.setAsDefault(); + var queryOptions = em1.queryOptions.using(breeze.MergeStrategy.PreserveChanges); + var queryOptions = em1.queryOptions.using(breeze.FetchStrategy.FromLocalCache); + var queryOptions = em1.queryOptions.using({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges }); +} + +function test_validationOptions() { + var newVo = new breeze.ValidationOptions({ validateOnSave: false, validateOnAttach: false }); + var em1: breeze.EntityManager; + em1.setProperties({ validationOptions: newVo }); + var validationOptions = new breeze.ValidationOptions() + var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false }); + newOptions.setAsDefault(); + var validationOptions = new breeze.ValidationOptions(); + var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false }); +} + +function test_validator() { + var valFn = function (v) { + if (v == null) return true; + return ( v.substr(0,2)=== "US"); + }; + var countryValidator = new breeze.Validator("countryIsUS", valFn, { + displayName: "Country", + messageTemplate: "'%displayName%' must start with 'US'" + }); + var metadataStore: breeze.MetadataStore; + var custType = metadataStore.getEntityType("Customer"); + var countryProp = custType.getProperty("Country"); + countryProp.validators.push(countryValidator); + function isValidZipCode(value) { + var re = /^\d{5}([\-]\d{4})?$/; + return (re.test(value)); + } + var valFn = function (v) { + if (v.getProperty("Country") === "USA") { + var postalCode = v.getProperty("PostalCode"); + return isValidZipCode(postalCode); + } + return true; + }; + var zipCodeValidator = new breeze.Validator("zipCodeValidator", valFn, + { messageTemplate: "For the US, this is not a valid PostalCode" }); + var em1: breeze.EntityManager; + var custType = em1.metadataStore.getEntityType("Customer"); + custType.validators.push(zipCodeValidator); + var numericRangeValidator = function (context) { + var valFn = function (v, ctx) { + if (v == null) return true; + if (typeof (v) !== "number") return false; + if (ctx.min != null && v < ctx.min) return false; + if (ctx.max != null && v > ctx.max) return false; + return true; + }; + return new breeze.Validator("numericRange", valFn, { + messageTemplate: "'%displayName%' must be an integer between the values of %min% and %max%", + min: context.min, + max: context.max + }); + }; + freightProperty.validators.push(numericRangeValidator({ min: 100, max: 500 })); + var productType = em1.metadataStore.getEntityType("Product"); + var discontinuedProperty = productType.getProperty("Discontinued"); + discontinuedProperty.validators.push(breeze.Validator.bool()); + var orderType = em1.metadataStore.getEntityType("Order"); + var freightProperty = orderType.getProperty("Freight"); + regionProperty.validators.push(breeze.Validator.byte()); + var orderType = em1.metadataStore.getEntityType("Order"); + var orderDateProperty = orderType.getProperty("OrderDate"); + orderDateProperty.validators.push(breeze.Validator.date()); + var v0 = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" }); + v0.validate("adasdfasdf"); + var errMessage = v0.getMessage(); + var custType = em1.metadataStore.getEntityType("Customer"); + var customerIdProperty = custType.getProperty("CustomerID"); + customerIdProperty.validators.push(breeze.Validator.guid()); + var orderType = em1.metadataStore.getEntityType("Order"); + var freightProperty = orderType.getProperty("Freight"); + freightProperty.validators.push(breeze.Validator.int16()); + var orderType = em1.metadataStore.getEntityType("Order"); + var freightProperty = orderType.getProperty("Freight"); + freightProperty.validators.push(breeze.Validator.int32()); + var orderType = em1.metadataStore.getEntityType("Order"); + var freightProperty = orderType.getProperty("Freight"); + freightProperty.validators.push(breeze.Validator.int64()); + var custType = em1.metadataStore.getEntityType("Customer"); + var regionProperty = custType.getProperty("Region"); + regionProperty.validators.push(breeze.Validator.maxLength({ maxLength: 5 })); + var orderType = em1.metadataStore.getEntityType("Order"); + var freightProperty = orderType.getProperty("Freight"); + freightProperty.validators.push(breeze.Validator.number()); + var custType = em1.metadataStore.getEntityType("Customer"); + var regionProperty = custType.getProperty("Region"); + regionProperty.validators.push(breeze.Validator.required()); + var custType = em1.metadataStore.getEntityType("Customer"); + var regionProperty = custType.getProperty("Region"); + regionProperty.validators.push(breeze.Validator.string()); + var custType = em1.metadataStore.getEntityType("Customer"); + var regionProperty = custType.getProperty("Region"); + regionProperty.validators.push(breeze.Validator.stringLength({ minLength: 2, maxLength: 5 })); + var validator = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" }); + var result = validator.validate("asdf"); + var ok = result === null; + result = validator.validate("adasdfasdf"); + var errMsg = result.errorMessage; + var context = result.context; + var sameValidator = result.validator; + var valFn = function (v) { + if (v == null) return true; + return (v.substr(0,2) === "US"); + }; + var countryValidator = new breeze.Validator("countryIsUS", valFn, { displayName: "Country" }); + breeze.Validator.messageTemplates["countryIsUS"] = "'%displayName%' must start with 'US'"; +} + +function test_demo() { + + var manager = new breeze.EntityManager('api/northwind'); + + var query = new breeze.EntityQuery() + .from("Employees"); + + manager.executeQuery(query).then(function (data) { }); +} diff --git a/breeze/breeze-1.0.d.ts b/breeze/breeze-1.0.d.ts new file mode 100644 index 000000000..8a6458498 --- /dev/null +++ b/breeze/breeze-1.0.d.ts @@ -0,0 +1,731 @@ +// Type definitions for Breeze 1.0 +// Project: http://www.breezejs.com/ +// Definitions by: Boris Yankov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +// Updated Jan 14 2011 - Jay Traband (www.ideablade.com) + + +declare module BreezeCore { + + interface ErrorCallback { + (error: Error): void; + } + + interface IEnum { + contains(object: any): bool; + fromName(name: string): EnumSymbol; + getNames(): string[]; + getSymbols(): EnumSymbol[]; + } + + class Enum implements IEnum { + constructor (name: string, methodObj?: any); + + addSymbol(propertiesObj?: any): EnumSymbol; + contains(object: any): bool; + fromName(name: string): EnumSymbol; + getNames(): string[]; + getSymbols(): EnumSymbol[]; + static isSymbol(object: any): bool; + seal(): void; + } + + class EnumSymbol { + parentEnum: IEnum; + + getName(): string; + toString(): string; + } + + class Event { + constructor (name: string, publisher: any, defaultErrorCallback?: ErrorCallback); + + static enable(eventName: string, target: any): void; + static enable(eventName: string, target: any, isEnabled: bool): void; + static enable(eventName: string, target: any, isEnabled: Function): void; + + static isEnabled(eventName: string, target: any): bool; + publish(data: any, publishAsync?: bool, errorCallback?: ErrorCallback): void; + publishAsync(data: any, errorCallback?: ErrorCallback): void; + subscribe(callback?: (data: any) => void ): number; + unsubscribe(unsubKey: number): bool; + } +} + +declare module Breeze { + + interface Entity { + entityAspect: EntityAspect; + entityType: EntityType; + } + + interface ComplexObject { + complexAspect: ComplexAspect; + complexType: ComplexType; + } + + interface IProperty { + name: string; + parentEntityType: EntityType; + validators: Validator[]; + isDataProperty: bool; + isNavigationProperty: bool; + } + + interface IStructuralType { + complexProperties: DataProperty[]; + dataProperties: DataProperty[]; + name: string; + namespace: string; + shortName: string; + unmappedProperties: DataProperty[]; + validators: Validator[]; + } + + class AutoGeneratedKeyType { + static Identity: AutoGeneratedKeyType; + static KeyGenerator: AutoGeneratedKeyType; + static None: AutoGeneratedKeyType; + } + + class ComplexAspect { + complexObject: ComplexObject; + entityAspect: EntityAspect; + parent: Object; + parentProperty: DataProperty; + propertyPath: string; + originalValues: Object; + } + + class ComplexType implements IStructuralType { + complexProperties: DataProperty[]; + dataProperties: DataProperty[]; + name: string; + namespace: string; + shortName: string; + unmappedProperties: DataProperty[]; + validators: Validator[]; + addProperty(dataProperty: DataProperty); + getProperties(): DataProperty[]; + } + + class DataProperty implements IProperty { + complexTypeName: string; + concurrencyMode: string; + dataType: DataTypeSymbol; + defaultValue: any; + fixedLength: bool; + isComplexProperty: bool; + isDataProperty: bool; + isNavigationProperty: bool; + isNullable: bool; + isPartOfKey: bool; + isUnmapped: bool; + + maxLength: number; + name: string; + nameOnServer: string; + parentEntityType: EntityType; + relatedNavigationProperty: NavigationProperty; + validators: Validator[]; + constructor (config: DataPropertyOptions); + } + + interface DataPropertyOptions { + complexTypeName?: string; + concurrencyMode?: string; + dataType?: DataTypeSymbol; + defaultValue?: any; + fixedLength?: bool; + isNullable?: bool; + isPartOfKey?: bool; + isUnmapped?: bool; + maxLength?: number; + name?: string; + nameOnServer?: string; + validators?: Validator[]; + } + + class DataService { + adapterName: string; + hasServerMetadata: bool; + serviceName: string; + constructor(config: DataServiceOptions); + } + + interface DataServiceOptions { + adapterName?: string; + hasServerMetadata?: bool; + serviceName?: string; + } + + class DataTypeSymbol extends BreezeCore.EnumSymbol { + defaultValue: any; + isNumeric: bool; + } + interface DataType extends BreezeCore.IEnum { + Binary: DataTypeSymbol; + Boolean: DataTypeSymbol; + Byte: DataTypeSymbol; + DateTime: DataTypeSymbol; + Decimal: DataTypeSymbol; + Double: DataTypeSymbol; + Guid: DataTypeSymbol; + Int16: DataTypeSymbol; + Int32: DataTypeSymbol; + Int64: DataTypeSymbol; + Single: DataTypeSymbol; + String: DataTypeSymbol; + Time: DataTypeSymbol; + Undefined: DataTypeSymbol; + toDataType(typeName: string): DataTypeSymbol; + parseDateFromServer(date: any): Date; + + } + declare var DataType: DataType; + + class EntityActionSymbol extends BreezeCore.EnumSymbol { + } + interface EntityAction extends BreezeCore.IEnum { + AcceptChanges: EntityActionSymbol; + Attach: EntityActionSymbol; + AttachOnImport: EntityActionSymbol; + AttachOnQuery: EntityActionSymbol; + Clear: EntityActionSymbol; + Detach: EntityActionSymbol; + EntityStateChange: EntityActionSymbol; + MergeOnImport: EntityActionSymbol; + MergeOnSave: EntityActionSymbol; + MergeOnQuery: EntityActionSymbol; + PropertyChange: EntityActionSymbol; + RejectChanges: EntityActionSymbol; + } + var EntityAction: EntityAction; + + class EntityAspect { + entity: Entity; + entityManager: EntityManager; + entityState: EntityStateSymbol; + isBeingSaved: bool; + originalValues: any; + + propertyChanged: PropertyChangedEvent; + validationErrorsChanged: ValidationErrorsChangedEvent; + + acceptChanges(): void; + addValidationError(validationError: ValidationError): void; + clearValidationErrors(): void; + getKey(forceRefresh?: bool): EntityKey; + + getValidationErrors(): ValidationError[]; + getValidationErrors(property: string): ValidationError[]; + getValidationErrors(property: IProperty): ValidationError[]; + + loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): Promise; + loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): Promise; + + rejectChanges(): void; + + removeValidationError(validator: Validator): void; + removeValidationError(validator: Validator, property: DataProperty): void; + removeValidationError(validator: Validator, property: NavigationProperty): void; + + setDeleted(): void; + setModified(): void; + setUnchanged(): void; + validateEntity(): bool; + + validateProperty(property: string, context?: any): bool; + validateProperty(property: DataProperty, context?: any): bool; + validateProperty(property: NavigationProperty, context?: any): bool; + } + + class PropertyChangedEventArgs { + entity: Entity; + propertyName: string; + oldValue: any; + newValue: any; + } + + class PropertyChangedEvent extends BreezeCore.Event { + subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number; + } + + class ValidationErrorsChangedEventArgs { + entity: Entity; + added: ValidationError[]; + removed: ValidationError[]; + } + + class ValidationErrorsChangedEvent extends BreezeCore.Event { + subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number; + } + + class EntityKey { + constructor (entityType: EntityType, keyValue: any); + constructor (entityType: EntityType, keyValues: any[]); + + equals(entityKey: EntityKey): bool; + static equals(k1: EntityKey, k2: EntityKey): bool; + } + + class EntityManager { + dataService: DataService; + keyGeneratorCtor: Function; + metadataStore: MetadataStore; + queryOptions: QueryOptions; + saveOptions: SaveOptions; + serviceName: string; + validationOptions: ValidationOptions; + + entityChanged: EntityChangedEvent; + hasChangesChanged: BreezeCore.Event; + + constructor (config?: EntityManagerOptions); + constructor (config?: string); + + addEntity(entity: Entity): Entity; + attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity; + clear(): void; + createEmptyCopy(): EntityManager; + detachEntity(entity: Entity): bool; + createEntity(entityTypeName: string, propertyInitializer: {}): Entity; + + executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; + executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; + + executeQueryLocally(query: EntityQuery): Entity[]; + exportEntities(entities?: Entity[]): string; + fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: bool): Entity; + fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: bool): Entity; + fetchEntityByKey(entityKey: EntityKey): Entity; + fetchMetadata(callback?: (schema: any) => void , errorCallback?: BreezeCore.ErrorCallback): Promise; + generateTempKeyValue(entity: Entity): any; + getChanges(): Entity[]; + getChanges(entityTypeName: string): Entity[]; + getChanges(entityTypeNames: string[]): Entity[]; + getChanges(entityType: EntityType): Entity[]; + getChanges(entityTypes: EntityType[]): Entity[]; + + getEntities(entityTypeName: string, entityState?: EntityStateSymbol): Entity[]; + getEntities(entityTypeNames?: string[], entityState?: EntityStateSymbol): Entity[]; + getEntities(entityTypeName?: string, entityStates?: EntityStateSymbol[]): Entity[]; + getEntities(entityTypeNames?: string[], entityStates?: EntityStateSymbol[]): Entity[]; + + getEntities(entityType: EntityType, entityState?: EntityStateSymbol): Entity[]; + getEntities(entityTypes?: EntityType[], entityState?: EntityStateSymbol): Entity[]; + getEntities(entityType?: EntityType, entityStates?: EntityStateSymbol[]): Entity[]; + getEntities(entityTypes?: EntityType[], entityStates?: EntityStateSymbol[]): Entity[]; + + getEntityByKey(typeName: string, keyValue: any): Entity; + getEntityByKey(typeName: string, keyValues: any[]): Entity; + getEntityByKey(entityKey: EntityKey): Entity; + + hasChanges(): bool; + hasChanges(entityTypeName: string): bool; + hasChanges(entityTypeNames: string[]): bool; + hasChanges(entityType: EntityType): bool; + hasChanges(entityTypes: EntityType[]): bool; + + static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager; + importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager; + + rejectChanges(): Entity[]; + saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Promise; + setProperties(config: EntityManagerProperties): void; + } + + interface EntityManagerOptions { + serviceName?: string; + dataService?: DataService; + metadataStore?: MetadataStore; + queryOptions?: QueryOptions; + saveOptions?: SaveOptions; + validationOptions?: ValidationOptions; + keyGeneratorCtor?: Function; + } + + interface EntityManagerProperties { + serviceName?: string; + dataService?: DataService; + queryOptions?: QueryOptions; + saveOptions?: SaveOptions; + validationOptions?: ValidationOptions; + keyGeneratorCtor?: Function; + } + + interface ExecuteQuerySuccessCallback { + (data: { results: Entity[]; query: EntityQuery; XHR: XMLHttpRequest; }): void; + } + + interface ExecuteQueryErrorCallback { + (error: { query: EntityQuery; XHR: XMLHttpRequest; }): void; + } + + interface SaveChangesSuccessCallback { + (saveResult: { entities: Entity[]; keyMappings: any; XHR: XMLHttpRequest; }): void; + } + + interface SaveChangesErrorCallback { + (error: { XHR: XMLHttpRequest; }): void; + } + + class EntityChangedEventArgs { + entity: Entity; + entityAction: EntityActionSymbol; + args: Object; + } + + class EntityChangedEvent extends BreezeCore.Event { + subscribe(callback?: (data: EntityChangedEventArgs) => void ): number; + } + + class EntityQuery { + entityManager: EntityManager; + orderByClause: OrderByClause; + parameters: Object; + queryOptions: QueryOptions; + resourceName: string; + skipCount: number; + takeCount: number; + wherePredicate: Predicate; + + constructor (resourceName?: string); + + execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; + executeLocally(): Entity[]; + expand(propertyPaths: string[]): EntityQuery; + expand(propertyPaths: string): EntityQuery; + static from(resourceName: string): EntityQuery; + from(resourceName: string): EntityQuery; + static fromEntities(entity: Entity): EntityQuery; + static fromEntities(entities: Entity[]): EntityQuery; + static fromEntityKey(entityKey: EntityKey): EntityQuery; + static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery; + inlineCount(enabled?: bool): EntityQuery; + orderBy(propertyPaths: string): EntityQuery; + orderBy(propertyPaths: string[]): EntityQuery; + orderByDesc(propertyPaths: string): EntityQuery; + orderByDesc(propertyPaths: string[]): EntityQuery; + select(propertyPaths: string): EntityQuery; + select(propertyPaths: string[]): EntityQuery; + skip(count: number): EntityQuery; + take(count: number): EntityQuery; + top(count: number): EntityQuery; + + using(obj: EntityManager): EntityQuery; + using(obj: MergeStrategySymbol): EntityQuery; + using(obj: FetchStrategySymbol): EntityQuery; + + where(predicate: Predicate): EntityQuery; + where(property: string, operator: string, value: any): EntityQuery; + where(property: string, operator: FilterQueryOpSymbol, value: any): EntityQuery; + where(predicate: FilterQueryOpSymbol): EntityQuery; + withParameters(params: Object): EntityQuery; + } + + interface OrderByClause { + } + + class EntityStateSymbol extends BreezeCore.EnumSymbol { + isAdded(): bool; + isAddedModifiedOrDeleted(): bool; + isDeleted(): bool; + isDetached(): bool; + isModified(): bool; + isUnchanged(): bool; + isUnchangedOrModified(): bool; + } + interface EntityState extends BreezeCore.IEnum { + Added: EntityStateSymbol; + Deleted: EntityStateSymbol; + Detached: EntityStateSymbol; + Modified: EntityStateSymbol; + Unchanged: EntityStateSymbol; + } + var EntityState: EntityState; + + class EntityType implements IStructuralType { + autoGeneratedKeyType: AutoGeneratedKeyType; + complexProperties: DataProperty[]; + concurrencyProperties: DataProperty[]; + dataProperties: DataProperty[]; + defaultResourceName: string; + foreignKeyProperties: DataProperty[]; + keyProperties: DataProperty[]; + metadataStore: MetadataStore; + name: string; + namespace: string; + navigationProperties: NavigationProperty[]; + shortName: string; + unmappedProperties: DataProperty[]; + validators: Validator[]; + + constructor (config: MetadataStore); + constructor (config: EntityTypeOptions); + + addProperty(property: IProperty): void; + addValidator(validator: Validator, property?: IProperty): void; + createEntity(initialValues?: Object): Entity; + getDataProperty(propertyName: string): DataProperty; + getEntityCtor(): Function; + getNavigationProperty(propertyName: string): NavigationProperty; + getProperties(): IProperty[]; + getProperty(propertyPath: string, throwIfNotFound?: bool): IProperty; + getPropertyNames(): string[]; + setProperties(config: EntityTypeProperties): void; + toString(): string; + } + + interface EntityTypeOptions { + shortName?: string; + namespace?: string; + autogeneratedKeyType?: AutoGeneratedKeyType; + defaultResourceName?: string; + } + + interface EntityTypeProperties { + autogeneratedKeyType?: AutoGeneratedKeyType; + defaultResourceName?: string; + } + + class FetchStrategySymbol extends BreezeCore.EnumSymbol { + } + interface FetchStrategy extends BreezeCore.IEnum { + FromLocalCache: FetchStrategySymbol; + FromServer: FetchStrategySymbol; + } + var FetchStrategy: FetchStrategy; + + class FilterQueryOpSymbol extends BreezeCore.EnumSymbol { + } + interface FilterQueryOp extends BreezeCore.IEnum { + Contains: FilterQueryOpSymbol; + EndsWith: FilterQueryOpSymbol; + Equals: FilterQueryOpSymbol; + GreaterThan: FilterQueryOpSymbol; + GreaterThanOrEqual: FilterQueryOpSymbol; + LessThan: FilterQueryOpSymbol; + LessThanOrEqual: FilterQueryOpSymbol; + NotEquals: FilterQueryOpSymbol; + StartsWith: FilterQueryOpSymbol; + } + var FilterQueryOp: FilterQueryOp; + + class LocalQueryComparisonOptions { + static caseInsensitiveSQL: LocalQueryComparisonOptions; + static defaultInstance: LocalQueryComparisonOptions; + + constructor (config: { name?: string; isCaseSensitive?: bool; usesSql92CompliantStringComparison?: bool; }); + + setAsDefault(): void; + } + + class MergeStrategySymbol extends BreezeCore.EnumSymbol { + } + interface MergeStrategy extends BreezeCore.IEnum { + OverwriteChanges: MergeStrategySymbol; + PreserveChanges: MergeStrategySymbol; + } + var MergeStrategy: MergeStrategy; + + class MetadataStore { + namingConvention: NamingConvention; + + constructor (config?: MetadataStoreOptions); + addDataService(dataService: DataService): void; + addEntityType(structuralType: IStructuralType): void; + exportMetadata(): string; + fetchMetadata(dataService: string, callback?: (data) => void , errorCallback?: BreezeCore.ErrorCallback): Promise; + fetchMetadata(dataService: DataService, callback?: (data) => void , errorCallback?: BreezeCore.ErrorCallback): Promise; + getDataService(serviceName: string): DataService; + getEntityType(entityTypeName: string, okIfNotFound?: bool): IStructuralType; + getEntityTypes(): IStructuralType[]; + hasMetadataFor(serviceName: string): bool; + static importMetadata(exportedString: string): MetadataStore; + importMetadata(exportedString: string): MetadataStore; + isEmpty(): bool; + registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void; + trackUnmappedType(entityCtor: Function, interceptor?: Function); + } + + interface MetadataStoreOptions { + namingConvention?: NamingConvention; + localQueryComparisonOptions?: LocalQueryComparisonOptions; + } + + class NamingConvention { + static camelCase: NamingConvention; + static defaultInstance: NamingConvention; + static none: NamingConvention; + + constructor (config: NamingConventionOptions); + + clientPropertyNameToServer(clientPropertyName: string): string; + clientPropertyNameToServer(clientPropertyName: string, property: IProperty): string; + + serverPropertyNameToClient(serverPropertyName: string): string; + serverPropertyNameToClient(serverPropertyName: string, property: IProperty): string; + + setAsDefault(); + } + + interface NamingConventionOptions { + serverPropertyNameToClient?: (name: string) => string; + clientPropertyNameToServer?: (name: string) => string; + } + + class NavigationProperty implements IProperty { + associationName: string; + entityType: EntityType; + foreignKeyNames: string[]; + inverse: NavigationProperty; + isDataProperty: bool; + isNavigationProperty: bool; + isScalar: bool; + name: string; + parentEntityType: EntityType; + relatedDataProperties: DataProperty[]; + validators: Validator[]; + + constructor (config: NavigationPropertyOptions); + } + + interface NavigationPropertyOptions { + name?: string; + nameOnServer?: string; + entityTypeName: string; + isScalar?: bool; + associationName?: string; + foreignKeyNames?: string[]; + foreignKeyNamesOnServer?: string[]; + validators?: Validator[]; + } + + class Predicate { + constructor (property: string, operator: string, value: any, valueIsLiteral?: bool); + constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: bool); + + and: PredicateMethod; + static and: PredicateMethod; + + static create: PredicateMethod; + + static isPredicate(o: any): bool; + + static not(predicate: Predicate): Predicate; + not(): Predicate; + + static or: PredicateMethod; + or: PredicateMethod; + + toFunction(): Function; + toString(): string; + validate(entityType: EntityType): void; + } + + interface PredicateMethod { + (predicates: Predicate[]): Predicate; + (...predicates: Predicate[]): Predicate; + (property: string, operator: string, value: any, valueIsLiteral?: bool): Predicate; + (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: bool): Predicate; + } + + class Promise { + fail(errorCallback: Function): Promise; + fin(finallyCallback: Function): Promise; + then(callback: Function): Promise; + } + + class QueryOptions { + static defaultInstance: QueryOptions; + fetchStrategy: FetchStrategySymbol; + mergeStrategy: MergeStrategySymbol; + + constructor (config?: QueryOptionsConfiguration); + + setAsDefault(): void; + using(config: QueryOptionsConfiguration): QueryOptions; + using(config: MergeStrategySymbol): QueryOptions; + using(config: FetchStrategySymbol): QueryOptions; + } + + interface QueryOptionsConfiguration { + fetchStrategy?: FetchStrategySymbol; + mergeStrategy?: MergeStrategySymbol; + } + + class SaveOptions { + allowConcurrentSaves: bool; + static defaultInstance: SaveOptions; + + constructor (config?: { allowConcurrentSaves?: bool; }); + + setAsDefault(): SaveOptions; + } + + class ValidationError { + context: any; + errorMessage: string; + property: IProperty; + propertyName: string; + validator: Validator; + + constructor (validator: Validator, context: any, errorMessage: string); + } + + class ValidationOptions { + static defaultInstance: ValidationOptions; + validateOnAttach: bool; + validateOnPropertyChange: bool; + validateOnQuery: bool; + validateOnSave: bool; + + constructor (config?: ValidationOptionsConfiguration); + + setAsDefault(): ValidationOptions; + using(config: ValidationOptionsConfiguration): ValidationOptions; + } + + interface ValidationOptionsConfiguration { + validateOnAttach?: bool; + validateOnSave?: bool; + validateOnQuery?: bool; + validateOnPropertyChange?: bool; + } + + class Validator { + static messageTemplates: any; + + constructor (name: string, validatorFn: ValidatorFunction, context?: any); + + static bool(): Validator; + static byte(): Validator; + static date(): Validator; + static duration(): Validator; + getMessage(): string; + static guid(): Validator; + static int16(): Validator; + static int32(): Validator; + static int64(): Validator; + static maxLength(context: { maxLength: number; }): Validator; + static number(): Validator; + static required(): Validator; + static string(): Validator; + static stringLength(context: { maxLength: number; minLength: number; }): Validator; + validate(value: any, context?: any): ValidationError; + } + + interface ValidatorFunction { + (value: any, context: ValidatorFunctionContext): void; + } + + interface ValidatorFunctionContext { + value: any; + validatorName: string; + displayName: string; + messageTemplate: string; + message?: string; + } +} diff --git a/breeze/breeze-tests.ts b/breeze/breeze-tests.ts index 09dd6a4a3..427547574 100644 --- a/breeze/breeze-tests.ts +++ b/breeze/breeze-tests.ts @@ -1,7 +1,6 @@ /// -import breeze = module(Breeze); -import core = module(BreezeCore); +import core = module(breezeCore); function test_dataType() { var typ = breeze.DataType.DateTime; @@ -9,9 +8,10 @@ function test_dataType() { var isNumber = typ.isNumeric; var dv = typ.defaultValue; var symbs = breeze.DataType.getSymbols(); - var x = typ.parentEnum === breeze.DataType; + var x = typ.parentEnum === breeze.DataType; var isFalse = breeze.DataType.contains(breeze.DataType.Double); var dt = breeze.DataType.fromName("Decimal"); + } function test_dataProperty() { @@ -33,6 +33,7 @@ function test_dataService() { var em = new breeze.EntityManager({ dataService: ds }); + } function test_entityAspect() { @@ -125,12 +126,13 @@ function test_metadataStore() { function test_entityManager() { var entityManager = new breeze.EntityManager("api/NorthwindIBModel"); - var entityManager = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); + var em1 = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); var metadataStore = new breeze.MetadataStore(); var entityManager = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel", metadataStore: metadataStore }); + return new breeze.QueryOptions({ mergeStrategy: null, fetchStrategy: this.fetchStrategy @@ -152,6 +154,10 @@ function test_entityManager() { var custType = em1.metadataStore.getEntityType("Customer"); var cust1 = custType.createEntity(); em1.addEntity(cust1); + + var cust2 = em1.createEntity("Customer", { companyName: "foo" }); + var cust3 = em1.createEntity("foo", { xxx: 3 }, breeze.EntityState.Added); + em1.attachEntity(cust1, breeze.EntityState.Added); em1.clear(); var em2 = em1.createEmptyCopy(); @@ -239,7 +245,8 @@ function test_entityManager() { if (em1.hasChanges(custType)) { } var custType = em1.metadataStore.getEntityType("Customer"); var orderType = em1.metadataStore.getEntityType("Order"); - if (em1.hasChanges([custType, orderType])) { } + if (em1.hasChanges([custType, orderType])) { }; + var bundle = em1.exportEntities(); window.localStorage.setItem("myEntityManager", bundle); var bundleFromStorage = window.localStorage.getItem("myEntityManager"); @@ -280,7 +287,7 @@ function test_entityManager() { }); var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); em.hasChangesChanged.subscribe(function (args) { - var hasChangesChanged = args.hasChanges; + var hasChanges = args.hasChanges; var entityManager = args.entityManager; }); } @@ -377,6 +384,8 @@ function test_entityQuery() { var em = new breeze.EntityManager(serviceName); var query = new breeze.EntityQuery("Orders") .using(breeze.FetchStrategy.FromLocalCache); + var adapter = new breeze.JsonResultsAdapter({ name: "foo", visitNode: function (x) { return x; } }); + var q2 = query.using(adapter); var query = new breeze.EntityQuery("Customers") .where("CompanyName", "startsWith", "C"); var query = new breeze.EntityQuery("Customers") @@ -393,6 +402,7 @@ function test_entityQuery() { .where("toLower(CompanyName)", "startsWith", "c"); var query = new breeze.EntityQuery("Customers") .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM"); + var q2 = query.toType("foo").orderBy("foo2"); } function test_entityState() { @@ -784,4 +794,4 @@ function test_demo() { .from("Employees"); manager.executeQuery(query).then(function (data) { }); -} +} \ No newline at end of file diff --git a/breeze/breeze.d.ts b/breeze/breeze.d.ts index 8a6458498..3f4532975 100644 --- a/breeze/breeze.d.ts +++ b/breeze/breeze.d.ts @@ -1,12 +1,13 @@ -// Type definitions for Breeze 1.0 +// Type definitions for Breeze 1.2.7 // Project: http://www.breezejs.com/ -// Definitions by: Boris Yankov -// Definitions: https://github.com/borisyankov/DefinitelyTyped +// Definitions by: Boris Yankov , +// IdeaBlade +// Definitions: https://github.com/borisyankov/DefinitelyTyped -// Updated Jan 14 2011 - Jay Traband (www.ideablade.com) +// Updated March 27 2013 - John Lantz (www.ideablade.com) -declare module BreezeCore { +declare module breezeCore { interface ErrorCallback { (error: Error): void; @@ -53,7 +54,7 @@ declare module BreezeCore { } } -declare module Breeze { +declare module breeze { interface Entity { entityAspect: EntityAspect; @@ -151,6 +152,7 @@ declare module Breeze { adapterName: string; hasServerMetadata: bool; serviceName: string; + jsonResultsAdapter: JsonResultsAdapter; constructor(config: DataServiceOptions); } @@ -158,13 +160,38 @@ declare module Breeze { adapterName?: string; hasServerMetadata?: bool; serviceName?: string; + jsonResultsAdapter?: JsonResultsAdapter; } - class DataTypeSymbol extends BreezeCore.EnumSymbol { + class JsonResultsAdapter { + name: string; + extractResults: (data: {}) => {}; + visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: bool; }; + constructor(config: { + name: string; + extractResults?: (data: {}) => {}; + visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: bool; }; + }); + } + + interface QueryContext { + query: any; // how to also say it could be an EntityQuery or a string + entityManager: EntityManager; + jsonResultsAdapter: JsonResultsAdapter; + mergeStrategy: MergeStrategy; + } + + interface NodeContext { + nodeType: string; + } + + + + class DataTypeSymbol extends breezeCore.EnumSymbol { defaultValue: any; isNumeric: bool; } - interface DataType extends BreezeCore.IEnum { + interface DataType extends breezeCore.IEnum { Binary: DataTypeSymbol; Boolean: DataTypeSymbol; Byte: DataTypeSymbol; @@ -185,9 +212,9 @@ declare module Breeze { } declare var DataType: DataType; - class EntityActionSymbol extends BreezeCore.EnumSymbol { + class EntityActionSymbol extends breezeCore.EnumSymbol { } - interface EntityAction extends BreezeCore.IEnum { + interface EntityAction extends breezeCore.IEnum { AcceptChanges: EntityActionSymbol; Attach: EntityActionSymbol; AttachOnImport: EntityActionSymbol; @@ -248,7 +275,7 @@ declare module Breeze { newValue: any; } - class PropertyChangedEvent extends BreezeCore.Event { + class PropertyChangedEvent extends breezeCore.Event { subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number; } @@ -258,7 +285,7 @@ declare module Breeze { removed: ValidationError[]; } - class ValidationErrorsChangedEvent extends BreezeCore.Event { + class ValidationErrorsChangedEvent extends breezeCore.Event { subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number; } @@ -280,7 +307,7 @@ declare module Breeze { validationOptions: ValidationOptions; entityChanged: EntityChangedEvent; - hasChangesChanged: BreezeCore.Event; + hasChangesChanged: HasChangesChangedEvent; constructor (config?: EntityManagerOptions); constructor (config?: string); @@ -289,18 +316,17 @@ declare module Breeze { attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity; clear(): void; createEmptyCopy(): EntityManager; + createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol) : Entity; detachEntity(entity: Entity): bool; - createEntity(entityTypeName: string, propertyInitializer: {}): Entity; - executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; executeQueryLocally(query: EntityQuery): Entity[]; exportEntities(entities?: Entity[]): string; - fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: bool): Entity; - fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: bool): Entity; - fetchEntityByKey(entityKey: EntityKey): Entity; - fetchMetadata(callback?: (schema: any) => void , errorCallback?: BreezeCore.ErrorCallback): Promise; + fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: bool): Promise; + fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: bool): Promise; + fetchEntityByKey(entityKey: EntityKey): Promise; + fetchMetadata(callback?: (schema: any) => void , errorCallback?: breezeCore.ErrorCallback): Promise; generateTempKeyValue(entity: Entity): any; getChanges(): Entity[]; getChanges(entityTypeName: string): Entity[]; @@ -377,10 +403,19 @@ declare module Breeze { args: Object; } - class EntityChangedEvent extends BreezeCore.Event { + class EntityChangedEvent extends breezeCore.Event { subscribe(callback?: (data: EntityChangedEventArgs) => void ): number; } + class HasChangesChangedEventArgs { + entityManager: EntityManager; + hasChanges: bool; + } + + class HasChangesChangedEvent extends breezeCore.Event { + subscribe(callback?: (data: HasChangesChangedEventArgs) => void ): number; + } + class EntityQuery { entityManager: EntityManager; orderByClause: OrderByClause; @@ -413,10 +448,13 @@ declare module Breeze { skip(count: number): EntityQuery; take(count: number): EntityQuery; top(count: number): EntityQuery; + toType(typeName: string): EntityQuery; + toType(type: EntityType): EntityQuery; using(obj: EntityManager): EntityQuery; using(obj: MergeStrategySymbol): EntityQuery; - using(obj: FetchStrategySymbol): EntityQuery; + using(obj: FetchStrategySymbol): EntityQuery; + using(obj: JsonResultsAdapter): EntityQuery; where(predicate: Predicate): EntityQuery; where(property: string, operator: string, value: any): EntityQuery; @@ -428,7 +466,7 @@ declare module Breeze { interface OrderByClause { } - class EntityStateSymbol extends BreezeCore.EnumSymbol { + class EntityStateSymbol extends breezeCore.EnumSymbol { isAdded(): bool; isAddedModifiedOrDeleted(): bool; isDeleted(): bool; @@ -437,7 +475,7 @@ declare module Breeze { isUnchanged(): bool; isUnchangedOrModified(): bool; } - interface EntityState extends BreezeCore.IEnum { + interface EntityState extends breezeCore.IEnum { Added: EntityStateSymbol; Deleted: EntityStateSymbol; Detached: EntityStateSymbol; @@ -490,17 +528,17 @@ declare module Breeze { defaultResourceName?: string; } - class FetchStrategySymbol extends BreezeCore.EnumSymbol { + class FetchStrategySymbol extends breezeCore.EnumSymbol { } - interface FetchStrategy extends BreezeCore.IEnum { + interface FetchStrategy extends breezeCore.IEnum { FromLocalCache: FetchStrategySymbol; FromServer: FetchStrategySymbol; } var FetchStrategy: FetchStrategy; - class FilterQueryOpSymbol extends BreezeCore.EnumSymbol { + class FilterQueryOpSymbol extends breezeCore.EnumSymbol { } - interface FilterQueryOp extends BreezeCore.IEnum { + interface FilterQueryOp extends breezeCore.IEnum { Contains: FilterQueryOpSymbol; EndsWith: FilterQueryOpSymbol; Equals: FilterQueryOpSymbol; @@ -522,9 +560,9 @@ declare module Breeze { setAsDefault(): void; } - class MergeStrategySymbol extends BreezeCore.EnumSymbol { + class MergeStrategySymbol extends breezeCore.EnumSymbol { } - interface MergeStrategy extends BreezeCore.IEnum { + interface MergeStrategy extends breezeCore.IEnum { OverwriteChanges: MergeStrategySymbol; PreserveChanges: MergeStrategySymbol; } @@ -537,8 +575,8 @@ declare module Breeze { addDataService(dataService: DataService): void; addEntityType(structuralType: IStructuralType): void; exportMetadata(): string; - fetchMetadata(dataService: string, callback?: (data) => void , errorCallback?: BreezeCore.ErrorCallback): Promise; - fetchMetadata(dataService: DataService, callback?: (data) => void , errorCallback?: BreezeCore.ErrorCallback): Promise; + fetchMetadata(dataService: string, callback?: (data) => void , errorCallback?: breezeCore.ErrorCallback): Promise; + fetchMetadata(dataService: DataService, callback?: (data) => void , errorCallback?: breezeCore.ErrorCallback): Promise; getDataService(serviceName: string): DataService; getEntityType(entityTypeName: string, okIfNotFound?: bool): IStructuralType; getEntityTypes(): IStructuralType[]; @@ -728,4 +766,4 @@ declare module Breeze { messageTemplate: string; message?: string; } -} +} \ No newline at end of file