From bbb295a8215ad121b86cea21d96881c694bc7f2f Mon Sep 17 00:00:00 2001 From: Steve Schmitt Date: Tue, 20 Jan 2015 22:13:42 -0800 Subject: [PATCH] Update to Breeze 1.5.2 --- breeze/breeze-tests.ts | 169 +++++++++--------- breeze/breeze.d.ts | 388 ++++++++++++++++++++++++++++++----------- 2 files changed, 367 insertions(+), 190 deletions(-) diff --git a/breeze/breeze-tests.ts b/breeze/breeze-tests.ts index 3fe45d8bf..a7720ea32 100644 --- a/breeze/breeze-tests.ts +++ b/breeze/breeze-tests.ts @@ -1,8 +1,3 @@ -// 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; @@ -28,7 +23,7 @@ function test_dataProperty() { maxLength: 20 }); var personEntityType: breeze.EntityType; - personEntityType.addProperty(lastNameProp); + personEntityType.addProperty(lastNameProp); } function test_dataService() { @@ -50,9 +45,9 @@ function test_entityAspect() { 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) { + order.entityAspect.loadNavigationProperty("Orders").then(function (data: breeze.QueryResult) { var orders = data.results; - }).fail(function (exception) { }); + }).catch(function (exception) { }); order.entityAspect.rejectChanges(); order.entityAspect.setDeleted(); order.entityAspect.setModified(); @@ -109,7 +104,7 @@ function test_metadataStore() { var ms = new breeze.MetadataStore(); ms.fetchMetadata("breeze/NorthwindIBModel") .then(function (rawMetadata) { }) - .fail(function (exception) { }); + .catch(function (exception) { }); var odType = em1.metadataStore.getEntityType("OrderDetail"); var badType = em1.metadataStore.getEntityType("Foo", false); var allTypes = em1.metadataStore.getEntityTypes(); @@ -172,14 +167,14 @@ function test_entityManager() { var em = new breeze.EntityManager(serviceName); var query = new breeze.EntityQuery("Orders"); em.executeQuery(query) - .then(function (data) { + .then(function (data: breeze.QueryResult) { var orders = data.results; - }).fail(function (err) { + }).catch(function (err) { }); var em = new breeze.EntityManager(serviceName); var query = new breeze.EntityQuery("Orders"); em.executeQuery(query, - function (data) { + function (data: breeze.QueryResult) { var orders = data.results; }, function (err) { @@ -187,9 +182,9 @@ function test_entityManager() { var em = new breeze.EntityManager(serviceName); var query = new breeze.EntityQuery("Orders").using(em); query.execute() - .then(function (data) { + .then(function (data: breeze.QueryResult) { var orders = data.results; - }).fail(function (err) { + }).catch(function (err) { }); var em = new breeze.EntityManager(serviceName); var query = new breeze.EntityQuery("Orders"); @@ -197,9 +192,9 @@ function test_entityManager() { var em = new breeze.EntityManager(serviceName); var query = new breeze.EntityQuery("Orders").using(breeze.FetchStrategy.FromLocalCache); em.executeQuery(query) - .then(function (data) { + .then(function (data: breeze.QueryResult) { var orders = data.results; - }).fail(function (err) { + }).catch(function (err) { }); var bundle = em1.exportEntities(); window.localStorage.setItem("myEntityManager", bundle); @@ -217,7 +212,7 @@ function test_entityManager() { .then(function () { var metadataStore = em1.metadataStore; }) - .fail(function (exception) { + .catch(function (exception) { }); var employeeType = em1.metadataStore.getEntityType("Employee"); var employeeKey = new breeze.EntityKey( employeeType, 1); @@ -228,7 +223,7 @@ function test_entityManager() { var custumer = custType.createEntity(); var customerId = em.generateTempKeyValue(custumer); em1.saveChanges() - .then(function (data) { + .then(function (data: breeze.SaveResult) { var sameCust1 = data.entities[0]; }); var changedEntities = em1.getChanges(); @@ -263,22 +258,22 @@ function test_entityManager() { metadataStore: em1.metadataStore }); em2.importEntities(bundle); - var bundle = em1.exportEntities(); - em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges }); - em.saveChanges().then(function (saveResult) { + var bundle2 = em1.exportEntities(null, { asString: true, includeMetadata: true }); + em2.importEntities(bundle2, { mergeStrategy: breeze.MergeStrategy.PreserveChanges }); + em.saveChanges().then(function (saveResult: breeze.SaveResult) { var savedEntities = saveResult.entities; var keyMappings = saveResult.keyMappings; - }).fail(function (e) { + }).catch(function (e) { }); var saveOptions = new breeze.SaveOptions({ allowConcurrentSaves: true }); var entitiesToSave: breeze.Entity[]; - em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult) { + em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult: breeze.SaveResult) { var savedEntities = saveResult.entities; var keyMappings = saveResult.keyMappings; - }).fail(function (e) { + }).catch(function (e) { }); em.saveChanges(entitiesToSave, null, - function (saveResult) { + function (saveResult: breeze.SaveResult) { var savedEntities = saveResult.entities; var keyMappings = saveResult.keyMappings; }, function (e) { } @@ -307,21 +302,21 @@ function test_entityQuery() { var em = new breeze.EntityManager(serviceName); var query = new breeze.EntityQuery("Orders").using(em); query.execute() - .then(function (data) { }) - .fail(function (err) { }); + .then(function (data: breeze.QueryResult) { }) + .catch(function (err) { }); var em = new breeze.EntityManager(serviceName); var query = new breeze.EntityQuery("Orders").using(em); query.execute( - function (data) { + function (data: breeze.QueryResult) { var orders = data.results; }, function (err) { }); var em = new breeze.EntityManager(serviceName); var query = new breeze.EntityQuery("Orders"); em.executeQuery(query) - .then(function (data) { + .then(function (data: breeze.QueryResult) { var orders = data.results; - }).fail(function (err) { + }).catch(function (err) { }); var query = new breeze.EntityQuery("Orders").using(em); var orders = query.executeLocally(); @@ -409,6 +404,8 @@ function test_entityQuery() { var query = new breeze.EntityQuery("Customers") .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM"); var q2 = query.toType("foo").orderBy("foo2"); + + var json = query.toJSON(); } function test_entityState() { @@ -487,55 +484,53 @@ function test_entityType() { } //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 }); +// 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"; +// 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"; //} - -interface CustomEntityManager extends breeze.EntityManager -{ - customTag: string; +interface CustomEntityManager extends breeze.EntityManager { + customTag: string; } function test_event() { @@ -699,14 +694,12 @@ function test_validationOptions() { var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false }); } -interface NumericRange -{ - max: number; +interface NumericRange{ + max: number; min: number; } -interface NumericRangeValidatorFunctionContext extends breeze.ValidatorFunctionContext, NumericRange -{ +interface NumericRangeValidatorFunctionContext extends breeze.ValidatorFunctionContext, NumericRange { } function test_validator() { @@ -726,7 +719,7 @@ function test_validator() { var re = /^\d{5}([\-]\d{4})?$/; return (re.test(value)); } - valFn = function (v: any) { + var valFn = function (v: any) { if (v.getProperty("Country") === "USA") { var postalCode = v.getProperty("PostalCode"); return isValidZipCode(postalCode); @@ -739,7 +732,7 @@ function test_validator() { var custType = em1.metadataStore.getEntityType("Customer"); custType.validators.push(zipCodeValidator); var numericRangeValidator = function (context: NumericRange) { - var valFn = function (v: any, ctx: NumericRangeValidatorFunctionContext) { + var valFn = function (v, ctx: NumericRangeValidatorFunctionContext) { if (v == null) return true; if (typeof (v) !== "number") return false; if (ctx.min != null && v < ctx.min) return false; @@ -799,15 +792,17 @@ function test_validator() { var errMsg = result.errorMessage; var context = result.context; var sameValidator = result.validator; - valFn = function (v: any) { + var valFn = function (v: any) { if (v == null) return true; - return (v.substr(0,2) === "US"); + 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"); + + var urlValidator = breeze.Validator.url({ messageTemplate: 'u got that wrong' }); } function test_demo() { @@ -817,7 +812,7 @@ function test_demo() { var query = new breeze.EntityQuery() .from("Employees"); - manager.executeQuery(query).then(function (data) { }); + manager.executeQuery(query).then(function (data: breeze.QueryResult) { }); } function test_corefns() { @@ -888,4 +883,4 @@ function test_config() { config.registerType(f1, "myCtor"); s = config.stringifyPad; o = config.typeRegistry; -} +} \ No newline at end of file diff --git a/breeze/breeze.d.ts b/breeze/breeze.d.ts index cf26f9aa1..cc7438e45 100644 --- a/breeze/breeze.d.ts +++ b/breeze/breeze.d.ts @@ -1,13 +1,15 @@ // Type definitions for Breeze 1.4 // Project: http://www.breezejs.com/ -// Definitions by: Boris Yankov , IdeaBlade +// Definitions by: Boris Yankov // 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). - -/// +// Updated Sep 26 2013 for Breeze 1.4.3 - Steve Schmitt ( www.ideablade.com). +// Updated Jul 22 2014 for Breeze 1.4.16 - Steve Schmitt ( www.ideablade.com) +// Updated Aug 22 2014 for Breeze 1.4.17 and removing Q dependency - Steve Schmitt ( www.ideablade.com) +// Updated Jan 16 2015 for Breeze 1.4.17 to add support for noimplicitany - Kevin Wilson ( www.kwilson.me.uk ) +// Updated Jan 20 2015 for Breeze 1.5.2 and merging changes from DefinitelyTyped declare module breeze.core { @@ -23,7 +25,7 @@ declare module breeze.core { } class Enum implements IEnum { - constructor (name: string, methodObj?: any); + constructor(name: string, methodObj?: any); addSymbol(propertiesObj?: any): EnumSymbol; contains(object: any): boolean; @@ -31,7 +33,7 @@ declare module breeze.core { getNames(): string[]; getSymbols(): EnumSymbol[]; static isSymbol(object: any): boolean; - seal(): void; + resolveSymbols(): void; } class EnumSymbol { @@ -42,7 +44,7 @@ declare module breeze.core { } class Event { - constructor (name: string, publisher: any, defaultErrorCallback?: ErrorCallback); + constructor(name: string, publisher: any, defaultErrorCallback?: ErrorCallback); static enable(eventName: string, target: any): void; static enable(eventName: string, target: any, isEnabled: boolean): void; @@ -51,25 +53,26 @@ declare module breeze.core { 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; + subscribe(callback?: (data: any) => void): number; unsubscribe(unsubKey: number): boolean; + clear(): void; } - export function objectForEach(obj: Object, kvfn: (key:string, value:any) => void): void; + 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: any[], a2: any[], equalsFn: (e1:any, e2:any) => boolean): boolean; - export function arrayFirst(a1: any[], predicate: (e:any) => boolean): any; + export function arrayEquals(a1: any[], a2: any[], equalsFn: (e1: any, e2: any) => boolean): boolean; + export function arrayFirst(a1: any[], predicate: (e: any) => boolean): any; export function arrayIndexOf(a1: any[], predicate: (e: any) => boolean): number; export function arrayRemoveItem(array: any[], item: any, shouldRemoveMultiple: boolean): any; export function arrayRemoveItem(array: any[], predicate: (e: any) => boolean, shouldRemoveMultiple: boolean): any; - export function arrayZip(a1: any[], a2: any[], callback: (e1:any, e2:any) => any): any[]; + export function arrayZip(a1: any[], a2: any[], callback: (e1: any, e2: any) => any): any[]; export function requireLib(libnames: string, errMessage: string): Object; export function using(obj: Object, property: string, tempValue: any, fn: () => any): any; - export function memoize(fn:Function): any; + export function memoize(fn: (...any: any[]) => any): any; export function getUuid(): string; export function durationToSeconds(duration: string): number; @@ -147,7 +150,6 @@ declare module breeze { concurrencyMode: string; dataType: DataTypeSymbol; defaultValue: any; - fixedLength: boolean; isComplexProperty: boolean; isDataProperty: boolean; isInherited: boolean; @@ -155,24 +157,26 @@ declare module breeze { isNullable: boolean; isPartOfKey: boolean; isUnmapped: boolean; - + maxLength: number; name: string; nameOnServer: string; parentType: IStructuralType; relatedNavigationProperty: NavigationProperty; validators: Validator[]; - constructor (config: DataPropertyOptions); + constructor(config: DataPropertyOptions); } interface DataPropertyOptions { complexTypeName?: string; concurrencyMode?: string; + custom?: any; dataType?: DataTypeSymbol; defaultValue?: any; - fixedLength?: boolean; + displayName?: string; isNullable?: boolean; isPartOfKey?: boolean; + isScalar?: boolean; isUnmapped?: boolean; maxLength?: number; name?: string; @@ -185,6 +189,7 @@ declare module breeze { adapterName: string; hasServerMetadata: boolean; serviceName: string; + uriBuilderName: string; jsonResultsAdapter: JsonResultsAdapter; useJsonp: boolean; constructor(config: DataServiceOptions); @@ -194,17 +199,18 @@ declare module breeze { interface DataServiceOptions { serviceName?: string; adapterName?: string; + uriBuilderName?: string; hasServerMetadata?: boolean; jsonResultsAdapter?: JsonResultsAdapter; useJsonp?: boolean; } class DataServiceAdapter { - checkForRecomposition(interfaceInitializedArgs: { interfaceName: string; isDefault: boolean}): void; + 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; + fetchMetadata(metadataStore: MetadataStore, dataService: DataService): breeze.promises.IPromise; + executeQuery(mappingContext: { getUrl: () => string; query: EntityQuery; dataService: DataService }): breeze.promises.IPromise; + saveChanges(saveContext: { resourceName: string; dataService: DataService }, saveBundle: Object): breeze.promises.IPromise; JsonResultsAdapter: JsonResultsAdapter; } @@ -232,9 +238,9 @@ declare module breeze { } class DataTypeSymbol extends breeze.core.EnumSymbol { - defaultValue: any; - isNumeric: boolean; - isDate: boolean; + defaultValue: any; + isNumeric: boolean; + isDate: boolean; } interface DataType extends breeze.core.IEnum { Binary: DataTypeSymbol; @@ -283,6 +289,7 @@ declare module breeze { entityState: EntityStateSymbol; isBeingSaved: boolean; originalValues: Object; + extraMetadata: Object; propertyChanged: PropertyChangedEvent; validationErrorsChanged: ValidationErrorsChangedEvent; @@ -299,8 +306,9 @@ declare module breeze { isNavigationPropertyLoaded(navigationProperty: string): boolean; isNavigationPropertyLoaded(navigationProperty: NavigationProperty): boolean; - loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): Q.Promise; - loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): Q.Promise; + + loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): breeze.promises.IPromise; + loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): breeze.promises.IPromise; rejectChanges(): void; @@ -309,10 +317,14 @@ declare module breeze { removeValidationError(validator: Validator, property: NavigationProperty): void; removeValidationError(validationError: ValidationError): void; + /** Sets the entity to an EntityState of 'Added'. This is NOT the equivalent of calling {{#crossLink "EntityManager/addEntity"}}{{/crossLink}} + because no key generation will occur for autogenerated keys as a result of this operation. */ + setAdded(): void; setDeleted(): void; setDetached(): void; setModified(): void; setUnchanged(): void; + setEntityState(entityState: EntityStateSymbol): void; validateEntity(): boolean; validateProperty(property: string, context?: any): boolean; @@ -322,13 +334,15 @@ declare module breeze { class PropertyChangedEventArgs { entity: Entity; + property: IProperty; propertyName: string; oldValue: any; newValue: any; + parent: any; } class PropertyChangedEvent extends breeze.core.Event { - subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number; + subscribe(callback?: (data: PropertyChangedEventArgs) => void): number; } class ValidationErrorsChangedEventArgs { @@ -338,12 +352,12 @@ declare module breeze { } class ValidationErrorsChangedEvent extends breeze.core.Event { - subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number; + subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void): number; } class EntityKey { - constructor (entityType: EntityType, keyValue: any); - constructor (entityType: EntityType, keyValues: any[]); + constructor(entityType: EntityType, keyValue: any); + constructor(entityType: EntityType, keyValues: any[]); equals(entityKey: EntityKey): boolean; static equals(k1: EntityKey, k2: EntityKey): boolean; @@ -356,6 +370,10 @@ declare module breeze { entityKey: EntityKey; fromCache: boolean; } + interface ExportEntitiesOptions { + asString: boolean; // default true + includeMetadata: boolean; // default true + } class EntityManager { dataService: DataService; @@ -370,26 +388,26 @@ declare module breeze { hasChangesChanged: HasChangesChangedEvent; validationErrorsChanged: ValidationErrorsChangedEvent; - constructor (config?: EntityManagerOptions); - constructor (config?: string); + constructor(config?: EntityManagerOptions); + constructor(config?: string); addEntity(entity: Entity): Entity; - attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity; + attachEntity(entity: Entity, entityState?: EntityStateSymbol, mergeStrategy?: MergeStrategySymbol): Entity; clear(): void; createEmptyCopy(): EntityManager; - createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol) : Entity; - createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol, mergeStrategy?: StrategySymbol): Entity; - createEntity(entityType: EntityType, config?: {}, entityState?: EntityStateSymbol): Entity; + createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol, mergeStrategy?: MergeStrategySymbol): Entity; + createEntity(entityType: EntityType, config?: {}, entityState?: EntityStateSymbol, mergeStrategy?: MergeStrategySymbol): Entity; detachEntity(entity: Entity): boolean; - executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Q.Promise; - executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Q.Promise; + executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): breeze.promises.IPromise; + executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): breeze.promises.IPromise; executeQueryLocally(query: EntityQuery): Entity[]; exportEntities(entities?: Entity[], includeMetadata?: boolean): string; - fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: boolean): Q.Promise; - fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: boolean): Q.Promise; - fetchEntityByKey(entityKey: EntityKey, checkLocalCacheFirst?: boolean): Q.Promise; - fetchMetadata(callback?: (schema: any) => void , errorCallback?: breeze.core.ErrorCallback): Q.Promise; + exportEntities(entities?: Entity[], options?: ExportEntitiesOptions): any; // string | Object + fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: boolean): breeze.promises.IPromise; + fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: boolean): breeze.promises.IPromise; + fetchEntityByKey(entityKey: EntityKey): breeze.promises.IPromise; + fetchMetadata(callback?: (schema: any) => void, errorCallback?: breeze.core.ErrorCallback): breeze.promises.IPromise; generateTempKeyValue(entity: Entity): any; getChanges(): Entity[]; getChanges(entityTypeName: string): Entity[]; @@ -417,13 +435,13 @@ declare module breeze { hasChanges(entityType: EntityType): boolean; hasChanges(entityTypes: EntityType[]): boolean; - static importEntities(exportedString: string, config?: { mergeStrategy?: StrategySymbol; }): EntityManager; - static importEntities(exportedData: Object, config?: { mergeStrategy?: StrategySymbol; }): EntityManager; - importEntities(exportedString: string, config?: { mergeStrategy?: StrategySymbol; }): EntityManager; - importEntities(exportedData: Object, config?: { mergeStrategy?: StrategySymbol; }): EntityManager; + static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; metadataVersionFn?: (any: any) => void }): EntityManager; + static importEntities(exportedData: Object, config?: { mergeStrategy?: MergeStrategySymbol; metadataVersionFn?: (any: any) => void }): EntityManager; + importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; metadataVersionFn?: (any: any) => void }): { entities: Entity[]; tempKeyMapping: { [key: string] : EntityKey } }; + importEntities(exportedData: Object, config?: { mergeStrategy?: MergeStrategySymbol; metadataVersionFn?: (any: any) => void }): { entities: Entity[]; tempKeyMapping: { [key: string]: EntityKey } }; rejectChanges(): Entity[]; - saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Q.Promise; + saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): breeze.promises.IPromise; setProperties(config: EntityManagerProperties): void; } @@ -451,15 +469,29 @@ declare module breeze { } interface ExecuteQueryErrorCallback { - (error: { query: EntityQuery; XHR: XMLHttpRequest; entityManager: EntityManager}): void; + (error: { query: EntityQuery; httpResponse: HttpResponse; entityManager: EntityManager; message?: string; stack?:string }): void; } interface SaveChangesSuccessCallback { (saveResult: SaveResult): void; } + interface EntityError { + entity: Entity; + errorMessage: string; + errorName: string; + isServerError: boolean; + propertyName: string; + } + interface SaveChangesErrorCallback { - (error: { XHR: XMLHttpRequest; }): void; + (error: { + entityErrors: EntityError[]; + httpResponse: HttpResponse; + message: string; + stack?: string; + status?: number + }): void; } class EntityChangedEventArgs { @@ -469,7 +501,7 @@ declare module breeze { } class EntityChangedEvent extends breeze.core.Event { - subscribe(callback?: (data: EntityChangedEventArgs) => void ): number; + subscribe(callback?: (data: EntityChangedEventArgs) => void): number; } class HasChangesChangedEventArgs { @@ -478,7 +510,7 @@ declare module breeze { } class HasChangesChangedEvent extends breeze.core.Event { - subscribe(callback?: (data: HasChangesChangedEventArgs) => void ): number; + subscribe(callback?: (data: HasChangesChangedEventArgs) => void): number; } class EntityQuery { @@ -492,9 +524,11 @@ declare module breeze { takeCount: number; wherePredicate: Predicate; - constructor (resourceName?: string); + constructor(resourceName?: string); + /** Create query from an expression tree */ + constructor(tree: Object); - execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Q.Promise; + execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): breeze.promises.IPromise; executeLocally(): Entity[]; expand(propertyPaths: string[]): EntityQuery; expand(propertyPaths: string): EntityQuery; @@ -505,9 +539,9 @@ declare module breeze { static fromEntityKey(entityKey: EntityKey): EntityQuery; static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery; inlineCount(enabled?: boolean): EntityQuery; - noTracking(enabled: boolean): EntityQuery; - orderBy(propertyPaths: string): EntityQuery; - orderBy(propertyPaths: string[]): EntityQuery; + noTracking(enabled?: boolean): EntityQuery; + orderBy(propertyPaths: string, isDescending?: boolean): EntityQuery; + orderBy(propertyPaths: string[], isDescending?: boolean): EntityQuery; orderByDesc(propertyPaths: string): EntityQuery; orderByDesc(propertyPaths: string[]): EntityQuery; select(propertyPaths: string): EntityQuery; @@ -522,14 +556,18 @@ declare module breeze { using(obj: DataService): EntityQuery; using(obj: JsonResultsAdapter): EntityQuery; using(obj: QueryOptions): EntityQuery; - using(obj: StrategySymbol): 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(property: string, filterop: FilterQueryOpSymbol, property2: string, filterop2: FilterQueryOpSymbol, value: any): EntityQuery; // for any/all clauses + where(property: string, filterop: string, property2: string, filterop2: string, value: any): EntityQuery; // for any/all clauses where(predicate: FilterQueryOpSymbol): EntityQuery; - where(property: string, filterop: FilterQueryOpSymbol, property2: string, filterop2: FilterQueryOpSymbol,value:any): EntityQuery; withParameters(params: Object): EntityQuery; + + toJSON(): string; } interface OrderByClause { @@ -571,8 +609,8 @@ declare module breeze { unmappedProperties: DataProperty[]; validators: Validator[]; - constructor (config: MetadataStore); - constructor (config: EntityTypeOptions); + constructor(config: MetadataStore); + constructor(config: EntityTypeOptions); addProperty(property: IProperty): void; addValidator(validator: Validator, property?: IProperty): void; @@ -601,10 +639,15 @@ declare module breeze { interface EntityTypeProperties { autoGeneratedKeyType?: AutoGeneratedKeyType; defaultResourceName?: string; - } + serializerFn?: (dataProperty: DataProperty, value: any) => any; + } + + class FetchStrategySymbol extends breeze.core.EnumSymbol { + private foo; // to distinguish this class from MergeStrategySymbol + } interface FetchStrategy extends breeze.core.IEnum { - FromLocalCache: StrategySymbol; - FromServer: StrategySymbol; + FromLocalCache: FetchStrategySymbol; + FromServer: FetchStrategySymbol; } var FetchStrategy: FetchStrategy; @@ -622,6 +665,7 @@ declare module breeze { NotEquals: FilterQueryOpSymbol; StartsWith: FilterQueryOpSymbol; Any: FilterQueryOpSymbol; + All: FilterQueryOpSymbol; } var FilterQueryOp: FilterQueryOp; @@ -629,16 +673,18 @@ declare module breeze { static caseInsensitiveSQL: LocalQueryComparisonOptions; static defaultInstance: LocalQueryComparisonOptions; - constructor (config: { name?: string; isCaseSensitive?: boolean; usesSql92CompliantStringComparison?: boolean; }); + constructor(config: { name?: string; isCaseSensitive?: boolean; usesSql92CompliantStringComparison?: boolean; }); setAsDefault(): void; } - class StrategySymbol extends breeze.core.EnumSymbol { + class MergeStrategySymbol extends breeze.core.EnumSymbol { } interface MergeStrategy extends breeze.core.IEnum { - OverwriteChanges: StrategySymbol; - PreserveChanges: StrategySymbol; + OverwriteChanges: MergeStrategySymbol; + PreserveChanges: MergeStrategySymbol; + SkipMerge: MergeStrategySymbol; + Disallowed: MergeStrategySymbol; } var MergeStrategy: MergeStrategy; @@ -646,11 +692,11 @@ declare module breeze { constructor(); constructor(config?: MetadataStoreOptions); namingConvention: NamingConvention; - addDataService(dataService: DataService): void; + addDataService(dataService: DataService, shouldOverwrite?: boolean): void; addEntityType(structuralType: IStructuralType): void; exportMetadata(): string; - fetchMetadata(dataService: string, callback?: (data: any) => void , errorCallback?: breeze.core.ErrorCallback): Q.Promise; - fetchMetadata(dataService: DataService, callback?: (data: any) => void , errorCallback?: breeze.core.ErrorCallback): Q.Promise; + fetchMetadata(dataService: string, callback?: (data: any) => void, errorCallback?: breeze.core.ErrorCallback): breeze.promises.IPromise; + fetchMetadata(dataService: DataService, callback?: (data: any) => void, errorCallback?: breeze.core.ErrorCallback): breeze.promises.IPromise; getDataService(serviceName: string): DataService; getEntityType(entityTypeName: string, okIfNotFound?: boolean): IStructuralType; getEntityTypes(): IStructuralType[]; @@ -658,11 +704,12 @@ declare module breeze { static importMetadata(exportedString: string): MetadataStore; importMetadata(exportedString: string, allowMerge?: boolean): MetadataStore; isEmpty(): boolean; - registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void; + registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) => void, noTrackingFn?: (entity: Entity) => Entity): void; trackUnmappedType(entityCtor: Function, interceptor?: Function): void; setEntityTypeForResourceName(resourceName: string, entityType: EntityType): void; setEntityTypeForResourceName(resourceName: string, entityTypeName: string): void; getEntityTypeNameForResourceName(resourceName: string): string; + setProperties(config: { name?: string; serializerFn?: Function }): void; } interface MetadataStoreOptions { @@ -675,7 +722,7 @@ declare module breeze { static defaultInstance: NamingConvention; static none: NamingConvention; - constructor (config: NamingConventionOptions); + constructor(config: NamingConventionOptions); clientPropertyNameToServer(clientPropertyName: string): string; clientPropertyNameToServer(clientPropertyName: string, property: IProperty): string; @@ -704,7 +751,7 @@ declare module breeze { relatedDataProperties: DataProperty[]; validators: Validator[]; - constructor (config: NavigationPropertyOptions); + constructor(config: NavigationPropertyOptions); } interface NavigationPropertyOptions { @@ -719,8 +766,12 @@ declare module breeze { } class Predicate { - constructor (property: string, operator: string, value: any, valueIsLiteral?: boolean); - constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean); + constructor(property: string, operator: string, value: any); + constructor(property: string, operator: FilterQueryOpSymbol, value: any); + constructor(property: string, operator: string, value: { value: any; isLiteral?: boolean; dataType?: breeze.DataType }); + constructor(property: string, operator: FilterQueryOpSymbol, value: { value: any; isLiteral?: boolean; dataType?: breeze.DataType }); + /** Create predicate from an expression tree */ + constructor(tree: Object); and: PredicateMethod; static and: PredicateMethod; @@ -738,6 +789,8 @@ declare module breeze { toFunction(): Function; toString(): string; validate(entityType: EntityType): void; + + toJSON(): string; } interface PredicateMethod { @@ -749,37 +802,56 @@ declare module breeze { class QueryOptions { static defaultInstance: QueryOptions; - fetchStrategy: StrategySymbol; - mergeStrategy: StrategySymbol; + fetchStrategy: FetchStrategySymbol; + mergeStrategy: MergeStrategySymbol; + /** Whether query should return cached deleted entities (false by default) */ + includeDeleted: boolean - constructor (config?: QueryOptionsConfiguration); + constructor(config?: QueryOptionsConfiguration); setAsDefault(): void; using(config: QueryOptionsConfiguration): QueryOptions; - using(config: StrategySymbol): QueryOptions; + using(config: MergeStrategySymbol): QueryOptions; + using(config: FetchStrategySymbol): QueryOptions; } interface QueryOptionsConfiguration { - fetchStrategy?: StrategySymbol; - mergeStrategy?: StrategySymbol; + fetchStrategy?: FetchStrategySymbol; + mergeStrategy?: MergeStrategySymbol; + } + + interface HttpResponse { + config: any; + data: Entity[]; + error?: any; + saveContext?: any; + status: number; + getHeaders(headerName: string): string } interface QueryResult { + /** Top level entities returned */ results: Entity[]; + /** Query that was executed */ query: EntityQuery; - XHR: XMLHttpRequest; + /** Raw response from the server */ + httpResponse: HttpResponse; + /** EntityManager that executed the query */ entityManager?: EntityManager; - inlineCount?: number + /** Total number of results available on the server */ + inlineCount?: number; + /** All entities returned by the query. Differs from results when an expand is used. */ + retrievedEntities?: Entity[] } class SaveOptions { allowConcurrentSaves: boolean; resourceName: string; dataService: DataService; - tag: string; + tag: Object; static defaultInstance: SaveOptions; - constructor (config?: { allowConcurrentSaves?: boolean; }); + constructor(config?: { allowConcurrentSaves?: boolean; }); setAsDefault(): SaveOptions; using(config: SaveOptionsConfiguration): SaveOptions; @@ -789,7 +861,7 @@ declare module breeze { allowConcurrentSaves?: boolean; resourceName?: string; dataService?: DataService; - tag?: string; + tag?: Object; } interface SaveResult { @@ -807,7 +879,7 @@ declare module breeze { validator: Validator; getKey: (validator: Validator, property: string) => string; - constructor (validator: Validator, context: any, errorMessage: string, key: string); + constructor(validator: Validator, context: any, errorMessage: string, key: string); } class ValidationOptions { @@ -817,7 +889,7 @@ declare module breeze { validateOnQuery: boolean; validateOnSave: boolean; - constructor (config?: ValidationOptionsConfiguration); + constructor(config?: ValidationOptionsConfiguration); setAsDefault(): ValidationOptions; using(config: ValidationOptionsConfiguration): ValidationOptions; @@ -831,31 +903,65 @@ declare module breeze { } class Validator { + /** Map of standard error message templates keyed by validator name.*/ static messageTemplates: any; context: any; name: string; - constructor (name: string, validatorFn: ValidatorFunction, context?: any); + constructor(name: string, validatorFn: ValidatorFunction, context?: any); static bool(): Validator; - static byte(): Validator; + /** integer between 0 and 255 inclusive */ + static byte(context?: { messageTemplate?: string }): Validator; static date(): Validator; + /** Returns a ISO 8601 duration string Validator. */ static duration(): Validator; + /** Validators number, double, and single are all the same */ + static number(context?: { messageTemplate?: string }): Validator; + /** Validators number, double, and single are all the same */ + static double(context?: { messageTemplate?: string }): Validator; + /** Validators number, double, and single are all the same */ + static single(context?: { messageTemplate?: string }): 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 int16(context?: { messageTemplate?: string }): Validator; + static int32(context?: { messageTemplate?: string }): Validator; + static int64(context?: { messageTemplate?: string }): Validator; + /** Same as int64 */ + static integer(context?: { messageTemplate?: string }): Validator; + static maxLength(context: { maxLength: number; messageTemplate?: string }): Validator; + static required(context?: { messageTemplate?: string }): Validator; static string(): Validator; - static stringLength(context: { maxLength: number; minLength: number; }): Validator; - - static register(validator: Validator): void; - static registerFactory(fn: () => Validator, name: string): void; + static stringLength(context: { maxLength: number; minLength: number; messageTemplate?: string }): Validator; + /** Returns a credit card number validator that performs a Luhn algorithm checksum test for plausability */ + static creditCard(context?: { messageTemplate?: string }): Validator; + /** Returns a regular expression validator; the expression must be specified in the context parameter */ + static regularExpression(context: { expression: RegExp; messageTemplate?: string }): Validator; + /** Returns the email address validator */ + static emailAddress(context?: { messageTemplate?: string }): Validator; + /** Returns the phone validator, which handles prefix, country code, area code, and local number, with [-/. ] break characters. */ + static phone(context?: { messageTemplate?: string }): Validator; + /** Returns the URL (protocol required) validator */ + static url(context?: { messageTemplate?: string }): Validator; + /** Always returns true */ + static none(): Validator; + /** Creates a validator instance from a JSON object or an array of instances from an array of JSON objects. */ + static fromJSON(json: string): Validator; + /** Register a validator instance so that any deserialized metadata can reference it. */ + static register(validator: Validator): void; + /** Register a validator factory so that any deserialized metadata can reference it. */ + static registerFactory(fn: () => Validator, name: string): void; + /** Creates a regular expression validator with a fixed expression. */ + static makeRegExpValidator(validatorName: string, expression: RegExp, defaultMessage: string, context?: any): Validator; + + /** Run this validator against the specified value. + @param value {Object} Value to validate + @param additionalContext {Object} Any additional contextual information that the Validator can make use of. + @return {ValidationError|null} A ValidationError if validation fails, null otherwise */ validate(value: any, context?: any): ValidationError; + + /** Returns the message generated by the most recent execution of this Validator. */ getMessage(): string; } @@ -881,18 +987,94 @@ declare module breeze.config { var ajax: string; var dataService: string; var functionRegistry: Object; - export function getAdapter(interfaceName: string, adapterName: string): Object; + /** + Returns the ctor function used to implement a specific interface with a specific adapter name. + @method getAdapter + @param interfaceName {String} One of the following interface names "ajax", "dataService" or "modelLibrary" + @param [adapterName] {String} The name of any previously registered adapter. If this parameter is omitted then + this method returns the "default" adapter for this interface. If there is no default adapter, then a null is returned. + @return {Function|null} Returns either a ctor function or null. + **/ + export function getAdapter(interfaceName: string, adapterName?: string): Function; + /** + Returns the adapter instance corresponding to the specified interface and adapter names. + @method getAdapterInstance + @param interfaceName {String} The name of the interface. + @param [adapterName] {String} - The name of a previously registered adapter. If this parameter is + omitted then the default implementation of the specified interface is returned. If there is + no defaultInstance of this interface, then the first registered instance of this interface is returned. + @return {an instance of the specified adapter} + **/ export function getAdapterInstance(interfaceName: string, adapterName?: string): Object; - export function initializeAdapterInstance(interfaceName: string, adapterName: string, isDefault: boolean): void; - export function initializeAdapterInstances(config: Object): void; + /** + Initializes a single adapter implementation. Initialization means either newing a instance of the + specified interface and then calling "initialize" on it or simply calling "initialize" on the instance + if it already exists. + @method initializeAdapterInstance + @param interfaceName {String} The name of the interface to which the adapter to initialize belongs. + @param adapterName {String} - The name of a previously registered adapter to initialize. + @param [isDefault=true] {Boolean} - Whether to make this the default "adapter" for this interface. + @return {an instance of the specified adapter} + **/ + export function initializeAdapterInstance(interfaceName: string, adapterName: string, isDefault?: boolean): void; + /** + Initializes a collection of adapter implementations and makes each one the default for its corresponding interface. + @method initializeAdapterInstances + @param config {Object} + @param [config.ajax] {String} - the name of a previously registered "ajax" adapter + @param [config.dataService] {String} - the name of a previously registered "dataService" adapter + @param [config.modelLibrary] {String} - the name of a previously registered "modelLibrary" adapter + @param [config.uriBuilder] {String} - the name of a previously registered "uriBuilder" adapter + @return [array of instances] + **/ + export function initializeAdapterInstances(config: Object): Object[]; var interfaceInitialized: Event; var interfaceRegistry: Object; var objectRegistry: Object; + /** + Method use to register implementations of standard breeze interfaces. Calls to this method are usually + made as the last step within an adapter implementation. + @method registerAdapter + @param interfaceName {String} - one of the following interface names "ajax", "dataService" or "modelLibrary" + @param adapterCtor {Function} - an ctor function that returns an instance of the specified interface. + **/ export function registerAdapter(interfaceName: string, adapterCtor: Function): void; export function registerFunction(fn: Function, fnName: string): void; export function registerType(ctor: Function, typeName: string): void; //static setProperties(config: Object): void; //deprecated + /** + Set the promise implementation, if Q.js is not found. + @param q - implementation of promise. @see http://wiki.commonjs.org/wiki/Promises/A + */ + export function setQ(q: breeze.promises.IPromiseService): void; var stringifyPad: string; var typeRegistry: Object; } + +/** Promises interface used by Breeze. Usually implemented by Q (https://github.com/kriskowal/q) or angular.$q using breeze.config.setQ(impl) */ +declare module breeze.promises { + interface IPromise { + then(onFulfill: (value: T) => U, onReject?: (reason: any) => U): IPromise; + then(onFulfill: (value: T) => IPromise, onReject?: (reason: any) => U): IPromise; + then(onFulfill: (value: T) => U, onReject?: (reason: any) => IPromise): IPromise; + then(onFulfill: (value: T) => IPromise, onReject?: (reason: any) => IPromise): IPromise; + catch(onRejected: (reason: any) => U): IPromise; + catch(onRejected: (reason: any) => IPromise): IPromise; + finally(finallyCallback: () => any): IPromise; + } + + interface IDeferred { + promise: IPromise; + resolve(value: T): void; + reject(reason: any): void; + } + + interface IPromiseService { + defer(): IDeferred; + reject(reason?: any): IPromise; + resolve(object: T): IPromise; + resolve(object: IPromise): IPromise; + } +} +