angular-odata 0.78.1 → 0.95.0

package/lib/resources/types/singleton.d.ts

@@ -1,71 +1,103 @@
 import { Observable } from 'rxjs';
-import { Expand, Select } from '../builder';
-import { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-options';
-import { EntityKey, ODataResource } from '../resource';
-import { ODataNavigationPropertyResource } from './navigation-property';
-import { ODataPropertyResource } from './property';
-import { ODataActionResource } from './action';
-import { ODataFunctionResource } from './function';
-import { HttpOptions } from './options';
-import { ODataEntity, ODataEntityAnnotations } from '../responses';
-import { ODataModel } from '../../models';
 import { ODataApi } from '../../api';
+import { ODataModel } from '../../models';
+import { ODataStructuredType } from '../../schema';
 import { QueryOptionNames } from '../../types';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntity } from '../responses';
+import { ODataActionResource } from './action';
+import { ODataFunctionResource } from './function';
+import { ODataNavigationPropertyResource } from './navigation-property';
+import { ODataOptions } from './options';
+import { ODataPropertyResource } from './property';
 export declare class ODataSingletonResource<T> extends ODataResource<T> {
-    static factory<R>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions): ODataSingletonResource<R>;
-    clone(): ODataSingletonResource<T>;
-    schema(): import("angular-odata").ODataStructuredType<T> | undefined;
-    asModel<M extends ODataModel<T>>(entity: Partial<T> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
+    static factory<S>(api: ODataApi, { path, schema, query, }: {
+        path: string;
+        schema?: ODataStructuredType<S>;
+        query?: ODataQueryOptions<S>;
+    }): ODataSingletonResource<S>;
     key(value: any): ODataSingletonResource<T>;
     keys(values: any[]): ODataSingletonResource<T>;
     navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;
     property<P>(path: string): ODataPropertyResource<P>;
     action<P, R>(path: string): ODataActionResource<P, R>;
     function<P, R>(path: string): ODataFunctionResource<P, R>;
-    select(opts: Select<T>): ODataSingletonResource<T>;
-    expand(opts: Expand<T>): ODataSingletonResource<T>;
-    format(opts: string): ODataSingletonResource<T>;
-    get segment(): {
-        singleton(): import("../path-segments").SegmentHandler;
-        keys(values?: (EntityKey<T> | undefined)[] | undefined): (EntityKey<any> | undefined)[];
-    };
-    get query(): {
-        select(opts?: Select<T> | undefined): import("../query-options").OptionHandler<Select<T>>;
-        expand(opts?: Expand<T> | undefined): import("../query-options").OptionHandler<Expand<T>>;
-        compute(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        format(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        apply(query: import("../query-options").QueryArguments<T>): void;
-    };
-    get(options?: HttpOptions & {
+    protected post(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
+    protected put(attrs: Partial<T>, options?: ODataOptions & {
+        etag?: string;
+    }): Observable<ODataEntity<T>>;
+    protected patch(attrs: Partial<T>, options?: ODataOptions & {
+        etag?: string;
+    }): Observable<ODataEntity<T>>;
+    protected delete(options?: ODataOptions & {
+        etag?: string;
+    }): Observable<any>;
+    protected get(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<ODataEntity<T>>;
-    post(attrs: Partial<T>, options?: HttpOptions): Observable<ODataEntity<T>>;
-    put(attrs: Partial<T>, options?: HttpOptions & {
+    /**
+     * Creates a new entity.
+     * @param attrs The entity attributes to create.
+     * @param options The options for the request.
+     * @returns The created entity with the annotations.
+     */
+    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
+    /**
+     * Updates an existing entity.
+     * @param attrs The entity attributes to update.
+     * @param options The options for the request.
+     * @returns The updated entity with the annotations.
+     */
+    update(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
-    patch(attrs: Partial<T>, options?: HttpOptions & {
+    /**
+     * Modifies an existing entity.
+     * @param attrs The entity attributes to modify.
+     * @param options The options for the request.
+     * @returns The modified entity with the annotations.
+     */
+    modify(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
-    delete(options?: HttpOptions & {
+    /**
+     * Delete an existing entity.
+     * @param options The options for the request.
+     * @returns Observable of the deleted entity.
+     */
+    destroy(options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
-    fetch(options?: HttpOptions & {
+    /**
+     * Fetch an existing entity.
+     * @param options The options for the request.
+     * @param etag The etag to use for the request.
+     * @returns Observable of the entity with the annotations.
+     */
+    fetch(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<ODataEntity<T>>;
-    fetchEntity(options?: HttpOptions & {
+    /**
+     * Fetch an existing entity.
+     * @param options The options for the request.
+     * @param etag The etag to use for the request.
+     * @returns Observable of the entity.
+     */
+    fetchEntity(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T | null>;
-    fetchModel(options?: HttpOptions & {
+    /**
+     * Fetch an existing entity and return a model.
+     * @param options The options for the request.
+     * @param etag The etag to use for the request.
+     * @returns Observable of the entity.
+     */
+    fetchModel<M extends ODataModel<T>>(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
-    }): Observable<ODataModel<T> | null>;
+    }): Observable<M | null>;
 }

package/lib/resources/types/value.d.ts

@@ -1,13 +1,22 @@
 import { Observable } from 'rxjs';
-import { ODataResource } from '../resource';
-import { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-options';
-import { HttpOptions } from './options';
 import { ODataApi } from '../../api';
+import { ODataStructuredType } from '../../schema/structured-type';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataOptions } from './options';
 export declare class ODataValueResource<T> extends ODataResource<T> {
-    static factory<V>(api: ODataApi, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions): ODataValueResource<V>;
-    clone(): ODataValueResource<T>;
-    schema(): undefined;
-    get(options?: HttpOptions): Observable<T>;
-    fetch(options?: HttpOptions): Observable<T>;
+    static factory<V>(api: ODataApi, { type, schema, segments, query, }: {
+        type?: string;
+        schema?: ODataStructuredType<V>;
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<V>;
+    }): ODataValueResource<V>;
+    protected get(options?: ODataOptions): Observable<T>;
+    /**
+     * Fetch the value of the resource.
+     * @param options OData options.
+     * @returns Observable of the value.
+     */
+    fetch(options?: ODataOptions): Observable<T>;
 }

package/lib/schema/annotation.d.ts

@@ -8,3 +8,21 @@ export declare class ODataAnnotation {
     properties?: string[];
     constructor(annot: AnnotationConfig);
 }
+export declare class ODataAnnotatable {
+    annotations: ODataAnnotation[];
+    constructor(config: {
+        annotations?: AnnotationConfig[];
+    });
+    /**
+     * Find an annotation inside the annotatable.
+     * @param predicate Function that returns true if the annotation match.
+     * @returns The annotation that matches the predicate.
+     */
+    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
+    /**
+     * Find an annotation inside the annotatable and return its value.
+     * @param term The term of the annotation to find.
+     * @returns The value of the annotation.
+     */
+    annotatedValue<T>(term: string | RegExp): T | undefined;
+}

package/lib/schema/callable.d.ts

@@ -1,25 +1,41 @@
-import { Parser, CallableConfig, Options } from '../types';
+import { CallableConfig, Options, Parser } from '../types';
+import { ODataSchemaElement } from './element';
+import { ODataCallableParser } from './parsers';
 import { ODataSchema } from './schema';
-import { ODataCallableParser } from '../parsers';
-export declare class ODataCallable<R> {
-    schema: ODataSchema;
-    name: string;
+export declare class ODataCallable<R> extends ODataSchemaElement {
     entitySetPath?: string;
     bound?: boolean;
     composable?: boolean;
     parser: ODataCallableParser<R>;
     constructor(config: CallableConfig, schema: ODataSchema);
     path(): string;
-    type({ alias }?: {
-        alias?: boolean;
-    }): string;
-    isTypeOf(type: string): boolean;
-    get api(): import("angular-odata").ODataApi;
     configure({ parserForType, }: {
         parserForType: (type: string) => Parser<any>;
     }): void;
+    /**
+     * Deseialize the given value from the callable.
+     * @param value Value to deserialize
+     * @param options Options for deserialization
+     * @returns Deserialized value
+     */
     deserialize(value: any, options?: Options): any;
+    /**
+     * Serialize the given value for the callable.
+     * @param value Value to serialize
+     * @param options Options for serialization
+     * @returns Serialized value
+     */
     serialize(value: any, options?: Options): any;
+    /**
+     * Encode the given value for the callable.
+     * @param value Value to encode
+     * @param options Options for encoding
+     * @returns Encoded value
+     */
     encode(value: any, options?: Options): any;
-    binding(): import("../parsers").ODataParameterParser<any> | undefined;
+    /**
+     * Returns the binding parameter of the callable.
+     * @returns The binding parameter of the callable.
+     */
+    binding(): import("./parsers").ODataParameterParser<any> | undefined;
 }

package/lib/schema/element.d.ts

@@ -0,0 +1,39 @@
+import { AnnotationConfig } from '../types';
+import { ODataAnnotatable } from './annotation';
+import { ODataSchema } from './schema';
+export declare class ODataSchemaElement extends ODataAnnotatable {
+    name: string;
+    schema: ODataSchema;
+    constructor(config: {
+        annotations?: AnnotationConfig[];
+        name: string;
+    }, schema: ODataSchema);
+    get api(): import("angular-odata").ODataApi;
+    /**
+     * Create a nicer looking title.
+     * Titleize is meant for creating pretty output.
+     * @param term The term of the annotation to find.
+     * @returns The titleized string.
+     */
+    titleize(term?: string | RegExp): string;
+    /**
+     * Returns a full type of the structured type including the namespace/alias.
+     * @param alias Use the alias of the namespace instead of the namespace.
+     * @returns The string representation of the type.
+     */
+    type({ alias }?: {
+        alias?: boolean;
+    }): string;
+    /**
+     * Returns a boolean indicating if the structured type is of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isTypeOf(type: string): boolean;
+    /**
+     * Returns a boolean indicating if the structured type is a sub type of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isSubtypeOf(schema: ODataSchemaElement): boolean;
+}

package/lib/schema/entity-container.d.ts

@@ -1,13 +1,8 @@
-import { ODataSchema } from './schema';
 import { EntityContainerConfig } from '../types';
+import { ODataSchemaElement } from './element';
 import { ODataEntitySet } from './entity-set';
-import { ODataAnnotation } from './annotation';
-export declare class ODataEntityContainer {
-    schema: ODataSchema;
-    name: string;
-    annotations: ODataAnnotation[];
+import { ODataSchema } from './schema';
+export declare class ODataEntityContainer extends ODataSchemaElement {
     entitySets: ODataEntitySet[];
     constructor(config: EntityContainerConfig, schema: ODataSchema);
-    get api(): import("angular-odata").ODataApi;
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
 }

package/lib/schema/entity-set.d.ts

@@ -1,16 +1,10 @@
-import { ODataSchema } from './schema';
 import { EntitySetConfig } from '../types';
-import { ODataAnnotation } from './annotation';
-export declare class ODataEntitySet {
-    schema: ODataSchema;
-    name: string;
+import { ODataSchemaElement } from './element';
+import { ODataSchema } from './schema';
+export declare class ODataEntitySet extends ODataSchemaElement {
     entityType: string;
     service: {
         new (...params: any[]): any;
     };
-    annotations: ODataAnnotation[];
     constructor(config: EntitySetConfig, schema: ODataSchema);
-    isTypeOf(type: string): boolean;
-    get api(): import("angular-odata").ODataApi;
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
 }

package/lib/schema/enum-type.d.ts

@@ -1,31 +1,58 @@
-import { ODataSchema } from './schema';
-import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from '../parsers';
 import { EnumTypeConfig, Options } from '../types';
-import { ODataAnnotation } from './annotation';
-export declare class ODataEnumType<E> {
-    schema: ODataSchema;
-    name: string;
+import { ODataSchemaElement } from './element';
+import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
+import { ODataSchema } from './schema';
+export declare class ODataEnumType<E> extends ODataSchemaElement {
     parser: ODataEnumTypeParser<E>;
     members: {
         [name: string]: number;
     } | {
         [value: number]: string;
     };
-    annotations: ODataAnnotation[];
     constructor(config: EnumTypeConfig<E>, schema: ODataSchema);
-    type({ alias }?: {
-        alias?: boolean;
-    }): string;
-    isTypeOf(type: string): boolean;
-    get api(): import("angular-odata").ODataApi;
     configure(): void;
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
+    /**
+     * Returns the fields of the enum type.
+     * @returns The fields of the enum type.
+     */
     fields(): ODataEnumTypeFieldParser[];
+    /**
+     * Find a field by name.
+     * @param name The name of the field
+     * @returns The field with the given name
+     */
     findFieldByName(name: string): ODataEnumTypeFieldParser | undefined;
+    /**
+     * Find a field by value.
+     * @param value The value of the field
+     * @returns The field with the given value
+     */
     findFieldByValue(value: number): ODataEnumTypeFieldParser | undefined;
-    fieldTitle(value: number | string, pattern?: RegExp): string;
+    /**
+     * Map the fields of the enum type.
+     * @param mapper Function that maps the value to the new value
+     * @returns The fields mapped by the mapper
+     */
     mapFields<T>(mapper: (field: ODataEnumTypeFieldParser) => T): T[];
+    /**
+     * Deseialize the given value from the enum type.
+     * @param value Value to deserialize
+     * @param options Options for deserialization
+     * @returns Deserialized value
+     */
     deserialize(value: any, options?: Options): E;
+    /**
+     * Serialize the given value for the enum type.
+     * @param value Value to serialize
+     * @param options Options for serialization
+     * @returns Serialized value
+     */
     serialize(value: E, options?: Options): any;
+    /**
+     * Encode the given value for the enum type.
+     * @param value Value to encode
+     * @param options Options for encoding
+     * @returns Encoded value
+     */
     encode(value: E, options?: Options): any;
 }

package/lib/schema/index.d.ts

@@ -4,3 +4,4 @@ export * from './callable';
 export * from './enum-type';
 export * from './structured-type';
 export * from './entity-set';
+export * from './parsers';

package/lib/{parsers → schema/parsers}/callable.d.ts

@@ -1,4 +1,4 @@
-import { Parser, Parameter, CallableConfig, OptionsHelper, Options } from '../types';
+import { CallableConfig, Options, OptionsHelper, Parameter, Parser } from '../../types';
 import { ODataEnumTypeParser } from './enum-type';
 import { ODataStructuredTypeParser } from './structured-type';
 export declare class ODataParameterParser<T> {
@@ -27,7 +27,7 @@ export declare class ODataCallableParser<R> implements Parser<R> {
     alias?: string;
     return?: {
         type: string;
-        callable?: boolean;
+        collection?: boolean;
     };
     parser: Parser<any>;
     parameters: ODataParameterParser<any>[];

package/lib/schema/parsers/edm.d.ts

@@ -0,0 +1,4 @@
+import { Parser } from '../../types';
+export declare const EDM_PARSERS: {
+    [type: string]: Parser<any>;
+};

package/lib/{parsers → schema/parsers}/enum-type.d.ts

@@ -1,13 +1,12 @@
-import { ODataAnnotation } from '../schema/annotation';
-import { EnumTypeConfig, Parser, OptionsHelper, EnumTypeFieldConfig, Options } from '../types';
-export declare class ODataEnumTypeFieldParser {
+import { EnumTypeConfig, EnumTypeFieldConfig, Options, OptionsHelper, Parser } from '../../types';
+import { ODataAnnotatable } from '../annotation';
+export declare class ODataEnumTypeFieldParser extends ODataAnnotatable {
     name: string;
     value: number;
-    annotations: ODataAnnotation[];
     constructor(name: string, field: EnumTypeFieldConfig);
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
+    titleize(term?: string | RegExp): string;
 }
-export declare class ODataEnumTypeParser<T> implements Parser<T> {
+export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements Parser<T> {
     name: string;
     namespace: string;
     alias?: string;
@@ -20,6 +19,13 @@ export declare class ODataEnumTypeParser<T> implements Parser<T> {
     fields: ODataEnumTypeFieldParser[];
     optionsHelper?: OptionsHelper;
     constructor(config: EnumTypeConfig<T>, namespace: string, alias?: string);
+    /**
+     * Create a nicer looking title.
+     * Titleize is meant for creating pretty output.
+     * @param term The term of the annotation to find.
+     * @returns The titleized string.
+     */
+    ttitelize(term?: string | RegExp): string;
     configure({ options }: {
         options: OptionsHelper;
     }): void;
@@ -29,7 +35,7 @@ export declare class ODataEnumTypeParser<T> implements Parser<T> {
     encode(value: T, options?: Options): any;
     toJsonSchema(): any;
     validate(member: string | number, { method, navigation, }?: {
-        method?: 'create' | 'update' | 'patch';
+        method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): string[] | undefined;
 }

package/lib/{parsers → schema/parsers}/structured-type.d.ts

@@ -1,6 +1,6 @@
-import { Parser, StructuredTypeFieldConfig, StructuredTypeConfig, OptionsHelper, Options } from '../types';
+import { Options, OptionsHelper, Parser, StructuredTypeConfig, StructuredTypeFieldConfig } from '../../types';
+import { ODataAnnotatable } from '../annotation';
 import { ODataEnumTypeParser } from './enum-type';
-import { ODataAnnotation } from '../schema/annotation';
 declare type JsonSchemaSelect<T> = Array<keyof T>;
 declare type JsonSchemaCustom<T> = {
     [P in keyof T]?: (schema: any, field: ODataStructuredTypeFieldParser<T[P]>) => any;
@@ -33,7 +33,7 @@ export declare class ODataReferential {
         referencedProperty: string;
     });
 }
-export declare class ODataStructuredTypeFieldParser<T> implements Parser<T> {
+export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable implements Parser<T> {
     name: string;
     private structuredType;
     type: string;
@@ -46,12 +46,10 @@ export declare class ODataStructuredTypeFieldParser<T> implements Parser<T> {
     precision?: number;
     scale?: number;
     referentials: ODataReferential[];
-    annotations: ODataAnnotation[];
     optionsHelper?: OptionsHelper;
     constructor(name: string, structuredType: ODataStructuredTypeParser<any>, field: StructuredTypeFieldConfig);
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
     validate(value: any, { method, navigation, }?: {
-        method?: 'create' | 'update' | 'patch';
+        method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): {
         [name: string]: any;
@@ -76,7 +74,7 @@ export declare class ODataStructuredTypeFieldParser<T> implements Parser<T> {
     isStructuredType(): boolean;
     structured(): ODataStructuredTypeParser<T>;
 }
-export declare class ODataStructuredTypeParser<T> implements Parser<T> {
+export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable implements Parser<T> {
     name: string;
     namespace: string;
     open: boolean;
@@ -88,8 +86,15 @@ export declare class ODataStructuredTypeParser<T> implements Parser<T> {
     fields: ODataStructuredTypeFieldParser<any>[];
     optionsHelper?: OptionsHelper;
     constructor(config: StructuredTypeConfig<T>, namespace: string, alias?: string);
+    /**
+     * Create a nicer looking title.
+     * Titleize is meant for creating pretty output.
+     * @param term The term of the annotation to find.
+     * @returns The titleized string.
+     */
+    titleize(term?: string | RegExp): string;
     isTypeOf(type: string): boolean;
-    typeFor(name: string): string | undefined;
+    isSubtypeOf(type: string): boolean;
     findChildParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): ODataStructuredTypeParser<any> | undefined;
     childParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): Parser<any>;
     deserialize(value: any, options?: Options): T;
@@ -106,7 +111,7 @@ export declare class ODataStructuredTypeParser<T> implements Parser<T> {
     toJsonSchema(options?: JsonSchemaOptions<T>): any;
     validate(attrs: any, { method, navigation, }?: {
         create?: boolean;
-        method?: 'create' | 'update' | 'patch';
+        method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): {
         [name: string]: any;

package/lib/schema/schema.d.ts

@@ -1,12 +1,12 @@
-import { ODataStructuredType } from './structured-type';
+import { ODataApi } from '../api';
+import { Parser, SchemaConfig } from '../types';
+import { ODataAnnotatable } from './annotation';
 import { ODataCallable } from './callable';
 import { ODataEntityContainer } from './entity-container';
-import { ODataEnumType } from './enum-type';
-import { ODataApi } from '../api';
-import { SchemaConfig, Parser } from '../types';
 import { ODataEntitySet } from './entity-set';
-import { ODataAnnotation } from './annotation';
-export declare class ODataSchema {
+import { ODataEnumType } from './enum-type';
+import { ODataStructuredType } from './structured-type';
+export declare class ODataSchema extends ODataAnnotatable {
     api: ODataApi;
     namespace: string;
     alias?: string;
@@ -14,11 +14,9 @@ export declare class ODataSchema {
     entities: ODataStructuredType<any>[];
     callables: ODataCallable<any>[];
     containers: ODataEntityContainer[];
-    annotations: ODataAnnotation[];
     constructor(config: SchemaConfig, api: ODataApi);
     isNamespaceOf(type: string): boolean | "" | undefined;
     get entitySets(): ODataEntitySet[];
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
     findEnumTypeForType<T>(type: string): ODataEnumType<T> | undefined;
     findStructuredTypeForType<T>(type: string): ODataStructuredType<T> | undefined;
     findCallableForType<T>(type: string, bindingType?: string): ODataCallable<T> | undefined;