From 64c9e43095e1a217050c87a65e976d432b3049df Mon Sep 17 00:00:00 2001 From: Boris Yankov Date: Sun, 11 Nov 2012 22:58:01 +0200 Subject: [PATCH] Add Breeze definitions and tests --- Definitions/breeze-0.65.d.ts | 582 ++++++++++++++++++++++++++ README.md | 119 +++--- Tests/breeze-tests.ts | 762 +++++++++++++++++++++++++++++++++++ 3 files changed, 1398 insertions(+), 65 deletions(-) create mode 100644 Definitions/breeze-0.65.d.ts create mode 100644 Tests/breeze-tests.ts diff --git a/Definitions/breeze-0.65.d.ts b/Definitions/breeze-0.65.d.ts new file mode 100644 index 000000000..f1ca8759f --- /dev/null +++ b/Definitions/breeze-0.65.d.ts @@ -0,0 +1,582 @@ +// Type definitions for Breeze 1.0 +// Project: http://www.breezejs.com/ +// Definitions by: Boris Yankov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + + + +interface Entity { + entityAspect: EntityAspect; + entityType: EntityType; +} + +interface ErrorCallback { + (error: Error): void; +} + +class AutoGeneratedKeyType { + static Identity: AutoGeneratedKeyType; + static KeyGenerator: AutoGeneratedKeyType; + static None: AutoGeneratedKeyType; +} + +interface DataPropertyOptions { + name?: string; + nameOnServer?: string; + dataType?: DataType; + isNullable?: bool; + isPartOfKey?: bool; + isUnmapped?: bool; + concurrencyMode?: string; + maxLength?: number; + fixedLength?: bool; + validators?: Validator[]; +} + +class DataProperty { + concurrencyMode: string; + dataType: DataType; + defaultValue: any; + fixedLength: bool; + isNullable: bool; + isPartOfKey: bool; + isUnmapped: bool; + maxLength: number; + name: string; + parentEntityType: EntityType; + relatedNavigationProperty: NavigationProperty; + validators: Validator[]; + + constructor (config: DataPropertyOptions); +} + +class DataType { + static Binary: DataType; + static Boolean: DataType; + static Byte: DataType; + static DateTime: DataType; + static Decimal: DataType; + static Double: DataType; + static Guid: DataType; + static Int16: DataType; + static Int32: DataType; + static Int64: DataType; + static Single: DataType; + static String: DataType; + static Undefined: DataType; + + defaultValue: any; + isNumeric: bool; + + static toDataType(typeName: string): DataType; +} + +class EntityAction { + static AcceptChanges: EntityAction; + static Attach: EntityAction; + static AttachOnImport: EntityAction; + static AttachOnQuery: EntityAction; + static Clear: EntityAction; + static Detach: EntityAction; + static EntityStateChange: EntityAction; + static MergeOnImport: EntityAction; + static MergeOnSave: EntityAction; + static MergeOnQuery: EntityAction; + static PropertyChange: EntityAction; + static RejectChanges: EntityAction; +} + +class EntityAspect { + entity: Entity; + entityManager: EntityManager; + entityState: EntityState; + isBeingSaved: bool; + originalValues: any; + + propertyChanged: BreezeEvent; + validationErrorsChanged: BreezeEvent; + + acceptChanges(): void; + addValidationError(validationError: ValidationError): void; + getKey(forceRefresh?: bool): EntityKey; + + getValidationErrors(): ValidationError[]; + getValidationErrors(property: string): ValidationError[]; + getValidationErrors(property: DataProperty): ValidationError[]; + getValidationErrors(property: NavigationProperty): 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 EntityKey { + constructor (entityType: EntityType, keyValue: any); + constructor (entityType: EntityType, keyValues: any[]); + + equals(entityKey: EntityKey): bool; + static equals(k1: EntityKey, k2: EntityKey): bool; +} + +interface EntityManagerOptions { + serviceName?: string; + metadataStore?: MetadataStore; + queryOptions?: QueryOptions; + saveOptions?: SaveOptions; + validationOptions?: ValidationOptions; + keyGeneratorCtor?: Function; + remoteAccessImplementation?: RemoteAccessImplementation; +} + +interface RemoteAccessImplementation { +} + +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; +} + +interface EntityManagerProperties { + serviceName?: string; + queryOptions?: QueryOptions; + saveOptions?: SaveOptions; + validationOptions?: ValidationOptions; + remoteAccessImplementation?: RemoteAccessImplementation; + keyGeneratorCtor?: Function; +} + +class EntityManager { + keyGeneratorCtor: Function; + metadataStore: MetadataStore; + queryOptions: QueryOptions; + remoteAccessImplementation: RemoteAccessImplementation; + saveOptions: SaveOptions; + serviceName: string; + validationOptions: ValidationOptions; + + entityChanged: BreezeEvent; + //hasChanges: BreezeEvent; + + constructor (config?: EntityManagerOptions); + constructor (config?: string); + + addEntity(entity: Entity): Entity; + attachEntity(entity: Entity, entityState?: EntityState): Entity; + clear(): void; + createEmptyCopy(): EntityManager; + detachEntity(entity: Entity): bool; + + executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; + executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; + + executeQueryLocally(query: EntityQuery): Entity[]; + exportEntities(entities?: Entity[]): string; + fetchMetadata(callback?: (schema: any) => void , errorCallback?: ErrorCallback): Promise; + findEntityByKey(entityKey: EntityKey): Entity; + generateTempKeyValue(entity: Entity): any; + getChanges(): Entity[]; + + getChanges(entityType: EntityType): Entity[]; + getChanges(entityTypes: EntityType[]): Entity[]; + + getEntities(entityTypes: EntityType, entityState?: EntityState): Entity[]; + getEntities(entityTypes?: EntityType[], entityState?: EntityState): Entity[]; + getEntities(entityType?: EntityType, entityStates?: EntityState[]): Entity[]; + getEntities(entityTypes?: EntityType[], entityStates?: EntityState[]): Entity[]; + + hasChanges(): bool; + hasChanges(entityType: EntityType): bool; + hasChanges(entityTypes: EntityType[]): bool; + + static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategy; }): EntityManager; + importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategy; }): EntityManager; + + rejectChanges(): Entity[]; + saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Promise; + setProperties(config: EntityManagerProperties): void; +} + +class EntityQuery { + entityManager: EntityManager; + orderByClause: OrderByClause; + 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; + 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; + orderBy(propertyPaths: string): EntityQuery; + orderByDesc(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: MergeStrategy): EntityQuery; + //using(obj: FetchStrategy): EntityQuery; !!! same signature as MergeStrategy + + where(predicate: Predicate): EntityQuery; + where(property: string, operator: string, value: any): EntityQuery; + where(property: string, operator: FilterQueryOp, value: any): EntityQuery; + where(predicate: FilterQueryOp): EntityQuery; +} + +interface OrderByClause { +} + +class EntityState { + static Added: EntityState; + static Deleted: EntityState; + static Detached: EntityState; + static Modified: EntityState; + static Unchanged: EntityState; + + isAdded(): bool; + isAddedModifiedOrDeleted(): bool; + isDeleted(): bool; + isDetached(): bool; + isModified(): bool; + isUnchanged(): bool; + isUnchangedOrModified(): bool; +} + +class EntityType { + autoGeneratedKeyType: AutoGeneratedKeyType; + 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: DataProperty): void; + addProperty(property: NavigationProperty): void; + addValidator(validator: Validator, property?: any): void; + createEntity(): Entity; + getDataProperty(propertyName: string): DataProperty; + getEntityCtor(): Function; + getNavigationProperty(propertyName: string): NavigationProperty; + getProperties(): any; + getProperty(propertyPath: string, throwIfNotFound?: bool): any; + getPropertyNames(): string[]; + setProperties(config: EntityTypeProperties): void; + toString(): string; +} + +interface EntityTypeOptions { + metadataStore?: MetadataStore; + serviceName?: string; + shortName?: string; + namespace?: string; + defaultResourceName?: string; +} + +interface EntityTypeProperties { + autogeneratedKeyType?: AutoGeneratedKeyType; + defaultResourceName?: string; +} + +class Enum { + 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: Enum; + + getName(): string; + toString(): string; +} + +class BreezeEvent { + 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; +} + +class FetchStrategy { + static FromLocalCache: MergeStrategy; + static FromServer: MergeStrategy; +} + +class FilterQueryOp { + static Contains: FilterQueryOp; + static EndsWith: FilterQueryOp; + static Equals: FilterQueryOp; + static GreaterThan: FilterQueryOp; + static GreaterThanOrEqual: FilterQueryOp; + static LessThan: FilterQueryOp; + static LessThanOrEqual: FilterQueryOp; + static NotEquals: FilterQueryOp; + static StartsWith: FilterQueryOp; +} + +class LocalQueryComparisonOptions { + static caseInsensitiveSQL: LocalQueryComparisonOptions; + static defaultInstance: LocalQueryComparisonOptions; + + constructor (config: { name?: string; isCaseSensitive?: bool; usesSql92CompliantStringComparison?: bool; }); + + setAsDefault(): void; +} + +class MergeStrategy { + static OverwriteChanges: MergeStrategy; + static PreserveChanges: MergeStrategy; +} + +class MetadataStore { + namingConvention: NamingConvention; + + constructor (config?: MetadataStoreOptions); + + exportMetadata(): string; + fetchMetadata(serviceName: string, remoteAccessImplementation?: RemoteAccessImplementation, callback?: (data) => void , errorCallback?: ErrorCallback): Promise; + getEntityType(entityTypeName: string, okIfNotFound?: bool): EntityType; + getEntityTypes(): EntityType[]; + 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: DataProperty): string; + clientPropertyNameToServer(clientPropertyName: string, property: NavigationProperty): string; + + serverPropertyNameToClient(serverPropertyName: string): string; + serverPropertyNameToClient(serverPropertyName: string, property: DataProperty): string; + serverPropertyNameToClient(serverPropertyName: string, property: NavigationProperty): string; + + setAsDefault(); +} + +interface NamingConventionOptions { + serverPropertyNameToClient?: Function; + clientPropertyNameToServer?: Function; +} + +class NavigationProperty { + 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); + constructor (property: string, operator: FilterQueryOp, value: any); + + 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): bool; +} + +interface PredicateMethod { + (predicates: Predicate[]): Predicate; + (...predicates: Predicate[]): Predicate; + (property: string, operator: string, value: any): Predicate; + (property: string, operator: FilterQueryOp, value: any): Predicate; +} + +class Promise { + fail(errorCallback: Function): Promise; + fin(finallyCallback: Function): Promise; + then(callback: Function): Promise; +} + +class QueryOptions { + static defaultInstance: QueryOptions; + fetchStrategy: FetchStrategy; + mergeStrategy: MergeStrategy; + + constructor (config?: QueryOptionsConfiguration); + + setAsDefault(): void; + using(config: QueryOptionsConfiguration): QueryOptions; + using(config: MergeStrategy): QueryOptions; + // using(config: FetchStrategy): QueryOptions; !!! same signature as MergeStrategy +} + +interface QueryOptionsConfiguration { + fetchStrategy?: FetchStrategy; + mergeStrategy?: MergeStrategy; +} + +class SaveOptions { + allowConcurrentSaves: bool; + static defaultInstance: SaveOptions; + + constructor (config?: { allowConcurrentSaves?: bool; }); + + setAsDefault(): SaveOptions; +} + +class ValidationError { + context: any; + errorMessage: string; + property: any; // DataProperty | NavigationProperty + 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; + 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; +} + +interface ValidatorFunction { + (value: any, context: ValidatorFunctionContext): void; +} + +interface ValidatorFunctionContext { + value: any; + validatorName: string; + displayName: string; + messageTemplate: string; + message?: string; +} \ No newline at end of file diff --git a/README.md b/README.md index 4d27c254d..ee8e66070 100644 --- a/README.md +++ b/README.md @@ -1,65 +1,54 @@ -DefinitelyTyped -=============== - -TypeScript type definitions repository for popular JavaScript libraries. - -The project aims to provide *high quality* definitions for the most popular libraries out there. - -Complete --------- -* [AngularJS](http://angularjs.org) (by [Diego Vilar](https://github.com/diegovilar)) ([wiki](https://github.com/borisyankov/DefinitelyTyped/wiki/AngularJS-Definitions-Usage-Notes)) -* [async](https://github.com/caolan/async) -* [Backbone.js](http://backbonejs.org/) -* [Bootstrap](http://twitter.github.com/bootstrap/) -* [CodeMirror](http://codemirror.net) (by [Franois de Campredon](https://github.com/fdecampredon)) -* [Chosen](http://harvesthq.github.com/chosen/) -* [dynatree](http://code.google.com/p/dynatree/) (by [Franois de Campredon](https://github.com/fdecampredon)) -* [EaselJS](http://www.createjs.com/#!/EaselJS) (by [Pedro Ferreira](https://bitbucket.org/drk4)) -* [ember.js](http://emberjs.com/) -* [Express](http://expressjs.com/) -* [Fancybox](http://fancybox.net/) -* [GoogleMaps](https://developers.google.com/maps/) (by [Esben Nepper](https://github.com/eNepper)) -* [Handlebars](http://handlebarsjs.com/) -* [History.js](https://github.com/balupton/History.js/) -* [Humane.js](http://wavded.github.com/humane-js/) (by [John Vrbanac](https://github.com/jmvrbanac)) -* [Impress.js](https://github.com/bartaz/impress.js) -* [Jasmine](http://pivotal.github.com/jasmine/) -* [jQuery.Globalize](https://github.com/jquery/globalize) -* [jQuery](http://jquery.com/) (from TypeScript samples) -* [jQuery Mobile](http://jquerymobile.com) -* [jQuery UI](http://jqueryui.com/) -* [Knockback](http://kmalakoff.github.com/knockback/) (by [Marcel Binot](https://github.com/docgit)) -* [Knockout.js](http://knockoutjs.com/) -* [Knockout.Mapping](https://github.com/SteveSanderson/knockout.mapping) -* [linq.js](http://linqjs.codeplex.com/) (by Marcin Najder (https://github.com/marcinnajder)) -* [Modernizr](http://modernizr.com/) -* [Moment.js](https://github.com/timrwood/moment) (by [Michael Lakerveld](https://github.com/Lakerfield)) -* [Mustache.js](https://github.com/janl/mustache.js) -* [Node.js](http://nodejs.org/) (from TypeScript samples) -* [node_redis](https://github.com/mranney/node_redis) -* [node-sqlserver](https://github.com/WindowsAzure/node-sqlserver) -* [PhoneGap](http://phonegap.com) -* [PreloadJS](http://www.createjs.com/#!/PreloadJS) (by [Pedro Ferreira](https://bitbucket.org/drk4)) -* [QUnit](http://qunitjs.com/) (by [Diullei Gomes](https://github.com/Diullei)) -* [Raphael](http://raphaeljs.com/) (by [CheCoxshall](https://github.com/CheCoxshall)) -* [Sammy.js](http://sammyjs.org/) -* [SoundJS](http://www.createjs.com/#!/SoundJS) (by [Pedro Ferreira](https://bitbucket.org/drk4)) -* [Spin](http://fgnass.github.com/spin.js/) -* [Sugar](http://sugarjs.com/) (by Josh Baldwin)(https://github.com/jbaldwin/) -* [Teechart](http://www.steema.com) (by [Steema]) (http://www.steema.com) -* [Toastr](https://github.com/CodeSeven/toastr) -* [TweenJS](http://www.createjs.com/#!/TweenJS) (by [Pedro Ferreira](https://bitbucket.org/drk4)) -* [Ubuntu Unity Web API](https://launchpad.net/libunity-webapps) (by [John Vrbanac](https://github.com/jmvrbanac)) -* [Underscore.js](http://underscorejs.org/) -* [Underscore.js (Typed)](http://underscorejs.org/) (by Josh Baldwin)(https://github.com/jbaldwin/) - -Next ----- -* Facebook SDK -* jQuery.Validate -* google.visualization -* Meteor -* Isotope -* Zepto -* Socket.IO -* MongoDB \ No newline at end of file +DefinitelyTyped +=============== + +TypeScript type definitions repository for popular JavaScript libraries. + +The project aims to provide *high quality* definitions for the most popular libraries out there. + +Complete +-------- +* [AngularJS](http://angularjs.org) (by [Diego Vilar](https://github.com/diegovilar)) ([wiki](https://github.com/borisyankov/DefinitelyTyped/wiki/AngularJS-Definitions-Usage-Notes)) +* [async](https://github.com/caolan/async) (by [Boris Yankov](https://github.com/borisyankov)) +* [Backbone.js](http://backbonejs.org/) (by [Boris Yankov](https://github.com/borisyankov)) +* [Bootstrap](http://twitter.github.com/bootstrap/) (by [Boris Yankov](https://github.com/borisyankov)) +* [Breeze](http://www.breezejs.com/) (by [Boris Yankov](https://github.com/borisyankov)) +* [CodeMirror](http://codemirror.net) (by [François de Campredon](https://github.com/fdecampredon)) +* [Chosen](http://harvesthq.github.com/chosen/) (by [Boris Yankov](https://github.com/borisyankov)) +* [dynatree](http://code.google.com/p/dynatree/) (by [François de Campredon](https://github.com/fdecampredon)) +* [EaselJS](http://www.createjs.com/#!/EaselJS) (by [Pedro Ferreira](https://bitbucket.org/drk4)) +* [ember.js](http://emberjs.com/) (by [Boris Yankov](https://github.com/borisyankov)) +* [Express](http://expressjs.com/) (by [Boris Yankov](https://github.com/borisyankov)) +* [Fancybox](http://fancybox.net/) (by [Boris Yankov](https://github.com/borisyankov)) +* [GoogleMaps](https://developers.google.com/maps/) (by [Esben Nepper](https://github.com/eNepper)) +* [Handlebars](http://handlebarsjs.com/) (by [Boris Yankov](https://github.com/borisyankov)) +* [History.js](https://github.com/balupton/History.js/) (by [Boris Yankov](https://github.com/borisyankov)) +* [Humane.js](http://wavded.github.com/humane-js/) (by [John Vrbanac](https://github.com/jmvrbanac)) +* [Impress.js](https://github.com/bartaz/impress.js) (by [Boris Yankov](https://github.com/borisyankov)) +* [Jasmine](http://pivotal.github.com/jasmine/) (by [Boris Yankov](https://github.com/borisyankov)) +* [jQuery.Globalize](https://github.com/jquery/globalize) (by [Boris Yankov](https://github.com/borisyankov)) +* [jQuery](http://jquery.com/) (from TypeScript samples) +* [jQuery Mobile](http://jquerymobile.com) (by [Boris Yankov](https://github.com/borisyankov)) +* [jQuery UI](http://jqueryui.com/) (by [Boris Yankov](https://github.com/borisyankov)) +* [Knockback](http://kmalakoff.github.com/knockback/) (by [Marcel Binot](https://github.com/docgit)) +* [Knockout.js](http://knockoutjs.com/) (by [Boris Yankov](https://github.com/borisyankov)) +* [Knockout.Mapping](https://github.com/SteveSanderson/knockout.mapping) (by [Boris Yankov](https://github.com/borisyankov)) +* [linq.js](http://linqjs.codeplex.com/) (by [Marcin Najder](https://github.com/marcinnajder)) +* [Modernizr](http://modernizr.com/) (by [Boris Yankov](https://github.com/borisyankov)) +* [Moment.js](https://github.com/timrwood/moment) (by [Michael Lakerveld](https://github.com/Lakerfield)) +* [Mustache.js](https://github.com/janl/mustache.js) (by [Boris Yankov](https://github.com/borisyankov)) +* [Node.js](http://nodejs.org/) (from TypeScript samples) +* [node_redis](https://github.com/mranney/node_redis) (by [Boris Yankov](https://github.com/borisyankov)) +* [node-sqlserver](https://github.com/WindowsAzure/node-sqlserver) (by [Boris Yankov](https://github.com/borisyankov)) +* [PhoneGap](http://phonegap.com) (by [Boris Yankov](https://github.com/borisyankov)) +* [PreloadJS](http://www.createjs.com/#!/PreloadJS) (by [Pedro Ferreira](https://bitbucket.org/drk4)) +* [QUnit](http://qunitjs.com/) (by [Diullei Gomes](https://github.com/Diullei)) +* [Raphael](http://raphaeljs.com/) (by [CheCoxshall](https://github.com/CheCoxshall)) +* [Sammy.js](http://sammyjs.org/) (by [Boris Yankov](https://github.com/borisyankov)) +* [SoundJS](http://www.createjs.com/#!/SoundJS) (by [Pedro Ferreira](https://bitbucket.org/drk4)) +* [Spin](http://fgnass.github.com/spin.js/) (by [Boris Yankov](https://github.com/borisyankov)) +* [Sugar](http://sugarjs.com/) (by [Josh Baldwin](https://github.com/jbaldwin/)) +* [Teechart](http://www.steema.com) (by [Steema](http://www.steema.com)) +* [Toastr](https://github.com/CodeSeven/toastr) (by [Boris Yankov](https://github.com/borisyankov)) +* [TweenJS](http://www.createjs.com/#!/TweenJS) (by [Pedro Ferreira](https://bitbucket.org/drk4)) +* [Underscore.js](http://underscorejs.org/) (by [Boris Yankov](https://github.com/borisyankov)) +* [Underscore.js (Typed)](http://underscorejs.org/) (by [Josh Baldwin](https://github.com/jbaldwin/)) \ No newline at end of file diff --git a/Tests/breeze-tests.ts b/Tests/breeze-tests.ts new file mode 100644 index 000000000..bf71bb634 --- /dev/null +++ b/Tests/breeze-tests.ts @@ -0,0 +1,762 @@ +/// + +function test_dataProperty() { + var lastNameProp = new DataProperty({ + name: "lastName", + dataType: DataType.String, + isNullable: true, + maxLength: 20 + }); + var personEntityType: EntityType; + personEntityType.addProperty(lastNameProp); +} + +function test_entityAspect() { + var order: 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: EntityManager; + var employee1: Entity; + var empType = em1.metadataStore.getEntityType("Employee"); + var entityKey = new EntityKey(empType, 1); + var empKey = employee1.entityAspect.getKey(); + var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory"); + var empTerrKey = new EntityKey(empTerrType, [1, 77]); + var empType = em1.metadataStore.getEntityType("Employee"); + var empKey1 = new EntityKey(empType, 1); + var empKey2 = employee1.entityAspect.getKey(); + if (empKey1.equals(empKey2)) { } + if (EntityKey.equals(empKey1, empKey2)) { } +} + +function test_metadataStore() { + var ms = new MetadataStore(); + var entityManager = new EntityManager({ + serviceName: "api/NorthwindIBModel", + metadataStore: ms + }); + var em1: EntityManager; + em1.setProperties({ metadataStore: ms }); + var metadataAsString = ms.exportMetadata(); + window.localStorage.setItem("metadata", metadataAsString); + var metadataFromStorage = window.localStorage.getItem("metadata"); + var newMetadataStore = new MetadataStore(); + newMetadataStore.importMetadata(metadataFromStorage); + var ms = new 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 = MetadataStore.importMetadata(metadataFromStorage); + var metadataAsString = ms.exportMetadata(); + window.localStorage.setItem("metadata", metadataAsString); + var metadataFromStorage = window.localStorage.getItem("metadata"); + var newMetadataStore = new 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 EntityManager("api/NorthwindIBModel"); + var entityManager = new EntityManager({ serviceName: "api/NorthwindIBModel" }); + var metadataStore = new MetadataStore(); + var entityManager = new EntityManager({ + serviceName: "api/NorthwindIBModel", + metadataStore: metadataStore + }); + return new QueryOptions({ + mergeStrategy: null, + fetchStrategy: this.fetchStrategy + }); + var queryOptions = new QueryOptions({ + mergeStrategy: MergeStrategy.OverwriteChanges, + fetchStrategy: FetchStrategy.FromServer + }); + var validationOptions = new ValidationOptions({ + validateOnAttach: true, + validateOnSave: true, + validateOnQuery: false + }); + var entityManager = new EntityManager({ + serviceName: "api/NorthwindIBModel", + queryOptions: queryOptions, + validationOptions: validationOptions + }); + var custType = em1.metadataStore.getEntityType("Customer"); + var cust1 = custType.createEntity(); + em1.addEntity(cust1); + em1.attachEntity(cust1, EntityState.Added); + em1.clear(); + var em2 = em1.createEmptyCopy(); + em1.detachEntity(cust1); + var serviceName: string; + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders"); + em.executeQuery(query) + .then(function (data) { + var orders = data.results; + }).fail(function (err) { + }); + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders"); + em.executeQuery(query, + function (data) { + var orders = data.results; + }, + function (err) { + }); + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders").using(em); + query.execute() + .then(function (data) { + var orders = data.results; + }).fail(function (err) { + }); + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders"); + var orders = em.executeQueryLocally(query); + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders").using(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 EntityManager({ + serviceName: em1.serviceName, + metadataStore: em1.metadataStore + }); + em2.importEntities(bundleFromStorage); + var entitiesToExport: Entity[]; + var bundle = em1.exportEntities(entitiesToExport); + em2.importEntities(bundle, { mergeStrategy: MergeStrategy.PreserveChanges }); + var em1 = new EntityManager("api/NorthwindIBModel"); + em1.fetchMetadata() + .then(function () { + var metadataStore = em1.metadataStore; + }) + .fail(function (exception) { + }); + var employeeType = em1.metadataStore.getEntityType("Employee"); + var employeeKey = new EntityKey(employeeType, 1); + var employee = em1.findEntityByKey(employeeKey); + 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], 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 = EntityManager.importEntities(bundleFromStorage); + var bundle = em1.exportEntities(); + var em2 = new EntityManager({ + serviceName: em1.serviceName, + metadataStore: em1.metadataStore + }); + em2.importEntities(bundle); + var bundle = em1.exportEntities(); + em2.importEntities(bundle, { mergeStrategy: MergeStrategy.PreserveChanges }); + em.saveChanges().then(function (saveResult) { + var savedEntities = saveResult.entities; + var keyMappings = saveResult.keyMappings; + }).fail(function (e) { + }); + var saveOptions = new SaveOptions({ allowConcurrentSaves: true }); + var entitiesToSave: 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 EntityManager({ serviceName: "api/NorthwindIBModel" }); + em.entityChanged.subscribe(function (changeArgs) { + var action = changeArgs.entityAction; + var entity = changeArgs.entity; + }); + var em = new EntityManager({ serviceName: "api/NorthwindIBModel" }); + em.hasChanges.subscribe(function (args) { + var hasChanges = args.hasChanges; + var entityManager = args.entityManager; + }); +} + +function test_entityQuery() { + var query = new EntityQuery("Customers"); + var query = new EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .orderBy("Region"); + var serviceName: string; + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders").using(em); + query.execute() + .then(function (data) { }) + .fail(function (err) { }); + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders").using(em); + query.execute( + function (data) { + var orders = data.results; + }, + function (err) { }); + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders"); + em.executeQuery(query) + .then(function (data) { + var orders = data.results; + }).fail(function (err) { + }); + var query = new EntityQuery("Orders").using(em); + var orders = query.executeLocally(); + var query = new EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .expand("Orders"); + var query = new EntityQuery("Orders") + .expand("Customer, Employee"); + var query = new EntityQuery("Orders") + .expand("Customer, OrderDetails, OrderDetails.Product"); + var query = EntityQuery.from("Customers"); + var query = new EntityQuery("Customers"); + var query = new EntityQuery().from("Customers"); + var customer: Entity; + var customers: Entity[]; + var customersQuery = EntityQuery.fromEntities(customers); + var customersQuery = EntityQuery.fromEntities(customers) + .where("Region", FilterQueryOp.NotEquals, null); + var customerQuery = EntityQuery.fromEntities(customer); + var metadataStore: MetadataStore; + var empType = metadataStore.getEntityType("Employee"); + var entityKey = new EntityKey(empType, 1); + var query = EntityQuery.fromEntityKey(entityKey); + var employee: Entity; + var entityKey = employee.entityAspect.getKey(); + var query = EntityQuery.fromEntityKey(entityKey); + var ordersNavProp = employee.entityType.getProperty("Orders"); + var query = EntityQuery.fromEntityNavigation(employee, ordersNavProp); + var query = new EntityQuery("Customers") + .orderBy("CompanyName"); + var query = new EntityQuery("Customers") + .orderBy("Region, CompanyName"); + var query = new EntityQuery("Products") + .orderBy("Category.CategoryName"); + var query = new EntityQuery("Customers") + .orderBy("CompanyName desc"); + var query = new EntityQuery("Customers") + .orderBy("Region desc, CompanyName desc"); + var query = new EntityQuery("Customers") + .orderByDesc("CompanyName"); + var query = new EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .select("CompanyName"); + var query = new EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .select("Orders"); + var query = new EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .select("CompanyName, Orders"); + var query = new EntityQuery("Orders") + .where("Customer.CompanyName", "startsWith", "C") + .select("Customer.CompanyName, Customer, OrderDate"); + var query = new EntityQuery("Customers") + .where("CompanyName", "startsWith", "C") + .skip(5); + var query = new EntityQuery("Customers") + .take(5); + var query = new EntityQuery("Customers") + .top(5); + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders") + .using(em); + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders") + .using(MergeStrategy.PreserveChanges); + var em = new EntityManager(serviceName); + var query = new EntityQuery("Orders") + .using(FetchStrategy.FromLocalCache); + var query = new EntityQuery("Customers") + .where("CompanyName", "startsWith", "C"); + var query = new EntityQuery("Customers") + .where("CompanyName", FilterQueryOp.StartsWith, "C"); + var pred = new Predicate("CompanyName", FilterQueryOp.StartsWith, "C"); + var query = new EntityQuery("Customers") + .where(pred); + var pred = Predicate.create("CompanyName", "startswith", "C").and("Region", FilterQueryOp.Equals, null); + var query = new EntityQuery("Customers") + .where(pred); + var query = new EntityQuery("Products") + .where("Category.CategoryName", "startswith", "S"); + var query = new EntityQuery("Customers") + .where("toLower(CompanyName)", "startsWith", "c"); + var query = new EntityQuery("Customers") + .where("toUpper(substring(CompanyName, 1, 2))", FilterQueryOp.Equals, "OM"); +} + +function test_entityState() { + var anEntity: Entity; + var es = anEntity.entityAspect.entityState; + return es.isAdded(); + return es === EntityState.Added; + var es = anEntity.entityAspect.entityState; + return es.isAddedModifiedOrDeleted(); + return es === EntityState.Added || es === EntityState.Modified || es === EntityState.Deleted; + var es = anEntity.entityAspect.entityState; + return es.isDeleted(); + return es === EntityState.Deleted; + var es = anEntity.entityAspect.entityState; + return es.isDetached(); + return es === EntityState.Detached; + var es = anEntity.entityAspect.entityState; + return es.isModified(); + return es === EntityState.Modified; + var es = anEntity.entityAspect.entityState; + return es.isUnchanged(); + return es === EntityState.Unchanged; + var es = anEntity.entityAspect.entityState; + return es.isUnchangedOrModified(); + return es === EntityState.Unchanged || es === EntityState.Modified; +} + +function test_entityType() { + var myMetadataStore: MetadataStore; + var myEntityType: EntityType; + var dataProperty1, dataProperty2, navigationProperty1: DataProperty; + var em1: EntityManager; + var entityManager = new 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 (core.stringStartsWith(v, "US")); + }; + var countryValidator = new Validator("countryIsUS", valFn, + { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" }); + custType.addValidator(countryValidator, countryProp); + countryProp.validators.push(countryValidator); + var someEntityLevelValidator: 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: AutoGeneratedKeyType.Identity, + defaultResourceName: "CustomersAndIncludedOrders" + }); +} + +function test_enum() { + var prototype = { + nextDay: function () { + var nextIndex = (this.dayIndex + 1) % 7; + return DayOfWeek.getSymbols()[nextIndex]; + } + }; + var DayOfWeek = new 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 (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 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 Enum; + 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: EntityManager; + var myEntity, person: Entity; + var salaryEvent = new BreezeEvent("salaryEvent", person); + BreezeEvent.enable("propertyChanged", myEntityManager, false); + BreezeEvent.enable("propertyChanged", myEntityManager, true); + BreezeEvent.enable("propertyChanged", myEntity.entityAspect, false); + BreezeEvent.enable("propertyChanged", myEntity.entityAspect, null); + BreezeEvent.enable("validationErrorsChanged", myEntityManager, function (em) { + return em.customTag === "blue"; + }); + BreezeEvent.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: 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 LocalQueryComparisonOptions({ + name: "caseSensitive-nonSQL", + isCaseSensitive: true, + usesSql92CompliantStringComparison: false + }); + lqco.setAsDefault(); + var ms = new MetadataStore({ localQueryComparisonOptions: lqco }); + var em = new EntityManager({ metadataStore: ms }); + var lqco = new LocalQueryComparisonOptions({ + isCaseSensitive: false, + usesSql92CompliantStringComparison: true + }); + lqco.setAsDefault(); +} + +function test_namingConventions() { + var namingConv = new 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 ms = new MetadataStore({ namingConvention: namingConv }); + var em = new EntityManager({ metadataStore: ms }); + var namingConv = new 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 NavigationProperty({ + name: "homeAddress", + entityTypeName: "Address:#myNamespace", + isScalar: true, + associationName: "address_person", + foreignKeyNames: ["homeAddressId"] + }); + var homeAddressIdProp = new DataProperty({ + name: "homeAddressId", + dataType: DataType.Int32 + }); + var personEntityType: EntityType; + personEntityType.addProperty(homeAddressProp); + personEntityType.addProperty(homeAddressIdProp); +} + +function test_predicate() { + var p1 = new Predicate("CompanyName", "StartsWith", "B"); + var query = new EntityQuery("Customers").where(p1); + var p2 = new Predicate("Region", FilterQueryOp.Equals, null); + var query = new EntityQuery("Customers").where(p2); + var dt = new Date(88, 9, 12); + var p1 = Predicate.create("OrderDate", "ne", dt); + var p2 = Predicate.create("ShipCity", "startsWith", "C"); + var p3 = Predicate.create("Freight", ">", 100); + var newPred = p1.and(p2, p3); + var preds = [p2, p3]; + var newPred = p1.and(preds); + var p4 = Predicate.create("ShipCity", "startswith", "F") + .and("Size", "gt", 2000); + var dt = new Date(88, 9, 12); + var p1 = Predicate.create("OrderDate", "ne", dt); + var p2 = Predicate.create("ShipCity", "startsWith", "C"); + var p3 = Predicate.create("Freight", ">", 100); + var newPred = Predicate.and(p1, p2, p3); + var preds = [p1, p2, p3]; + var newPred = Predicate.and(preds); + var p1 = Predicate.create("Freight", "gt", 100); + var predArgs: any[] = ["Freight", "gt", 100]; + var p1 = Predicate.create(predArgs); + var p1 = new Predicate("Freight", "gt", 100); + var p1 = new Predicate("CompanyName", "StartsWith", "B"); + if (Predicate.isPredicate(p1)) { } + var p1 = Predicate.create("Freight", "gt", 100); + var not_p1 = Predicate.not(p1); + var not_p1 = p1.not(); + var not_p1 = Predicate.create("Freight", "le", 100); + var dt = new Date(88, 9, 12); + var p1 = Predicate.create("OrderDate", "ne", dt); + var p2 = Predicate.create("ShipCity", "startsWith", "C"); + var p3 = Predicate.create("Freight", ">", 100); + var newPred = Predicate.or(p1, p2, p3); + var preds = [p1, p2, p3]; + var newPred = Predicate.or(preds); + var dt = new Date(88, 9, 12); + var p1 = Predicate.create("OrderDate", "ne", dt); + var p2 = Predicate.create("ShipCity", "startsWith", "C"); + var p3 = Predicate.create("Freight", ">", 100); + var newPred = p1.and(p2, p3); + var preds = [p2, p3]; + var newPred = p1.and(preds); + var p4 = Predicate.create("ShipCity", "startswith", "F") + .or("Size", "gt", 2000); +} + +function test_queryOptions() { + var em1: EntityManager; + var newQo = new QueryOptions({ mergeStrategy: MergeStrategy.OverwriteChanges }); + em1.setProperties({ queryOptions: newQo }); + var newQo = new QueryOptions({ mergeStrategy: MergeStrategy.OverwriteChanges }); + newQo.setAsDefault(); + var queryOptions = em1.defaultQueryOptions.using(MergeStrategy.PreserveChanges); + var queryOptions = em1.defaultQueryOptions.using(FetchStrategy.FromLocalCache); + var queryOptions = em1.defaultQueryOptions.using({ mergeStrategy: OverwriteChanges }); +} + +function test_validationOptions() { + var newVo = new ValidationOptions({ validateOnSave: false, validateOnAttach: false }); + var em1: EntityManager; + em1.setProperties({ validationOptions: newVo }); + var validationOptions = new ValidationOptions() + var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false }); + newOptions.setAsDefault(); + var validationOptions = new ValidationOptions(); + var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false }); +} + +function test_validator() { + var valFn = function (v) { + if (v == null) return true; + return (core.stringStartsWith(v, "US")); + }; + var countryValidator = new Validator("countryIsUS", valFn, { + displayName: "Country", + messageTemplate: "'%displayName%' must start with 'US'" + }); + var metadataStore: MetadataStore; + var custType = metadataStore.getEntityType("Customer"); + var countryProp = custType.getProperty("Country"); + prop.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 Validator("zipCodeValidator", valFn, + { messageTemplate: "For the US, this is not a valid PostalCode" }); + var em1: 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 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(Validator.bool()); + var orderType = em1.metadataStore.getEntityType("Order"); + var freightProperty = orderType.getProperty("Freight"); + regionProperty.validators.push(Validator.byte()); + var orderType = em1.metadataStore.getEntityType("Order"); + var orderDateProperty = orderType.getProperty("OrderDate"); + orderDateProperty.validators.push(Validator.date()); + var v0 = 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(Validator.guid()); + var orderType = em1.metadataStore.getEntityType("Order"); + var freightProperty = orderType.getProperty("Freight"); + freightProperty.validators.push(Validator.int16()); + var orderType = em1.metadataStore.getEntityType("Order"); + var freightProperty = orderType.getProperty("Freight"); + freightProperty.validators.push(Validator.int32()); + var orderType = em1.metadataStore.getEntityType("Order"); + var freightProperty = orderType.getProperty("Freight"); + freightProperty.validators.push(Validator.int64()); + var custType = em1.metadataStore.getEntityType("Customer"); + var regionProperty = custType.getProperty("Region"); + regionProperty.validators.push(Validator.maxLength({ maxLength: 5 })); + var orderType = em1.metadataStore.getEntityType("Order"); + var freightProperty = orderType.getProperty("Freight"); + freightProperty.validators.push(Validator.number()); + var custType = em1.metadataStore.getEntityType("Customer"); + var regionProperty = custType.getProperty("Region"); + regionProperty.validators.push(Validator.required()); + var custType = em1.metadataStore.getEntityType("Customer"); + var regionProperty = custType.getProperty("Region"); + regionProperty.validators.push(Validator.string()); + var custType = em1.metadataStore.getEntityType("Customer"); + var regionProperty = custType.getProperty("Region"); + regionProperty.validators.push(Validator.stringLength({ minLength: 2, maxLength: 5 })); + var validator = Validator.maxLength({ maxLength: 5, displayName: "City" }); + var result = validator.validate("asdf"); + 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 (core.stringStartsWith(v, "US")); + }; + var countryValidator = new Validator("countryIsUS", valFn, { displayName: "Country" }); + Validator.messageTemplates["countryIsUS", "'%displayName%' must start with 'US'"); +} + +function test_demo() { + var core = breeze.core, + entityModel = breeze.entityModel; + + core.config.setProperties({ + trackingImplementation: entityModel.entityTracking_ko, + remoteAccessImplementation: entityModel.remoteAccess_webApi + }); + + var manager = new entityModel.EntityManager('api/northwind'); + + var query = new entityModel.EntityQuery() + .from("Employees"); + + manager.executeQuery(query).then(function (data) { }); +} \ No newline at end of file