angular-odata 0.115.0 → 0.120.0

package/lib/client.d.ts

@@ -2,6 +2,7 @@ import { HttpClient, HttpEvent } from '@angular/common/http';
 import { Injector } from '@angular/core';
 import { Observable } from 'rxjs';
 import { ODataApi } from './api';
+import { ODataConfigLoader } from './loaders';
 import { ODataCollection, ODataModel } from './models/index';
 import { ODataActionResource, ODataBatchResource, ODataEntityResource, ODataEntitySetResource, ODataFunctionResource, ODataMetadataResource, ODataNavigationPropertyResource, ODataOptions, ODataResource, ODataResponse, ODataSegment, ODataSingletonResource } from './resources/index';
 import { ODataEntityService } from './services/entity';
@@ -9,9 +10,10 @@ import { ODataSettings } from './settings';
 import * as i0 from "@angular/core";
 export declare class ODataClient {
     private http;
-    private settings;
+    private loader;
     private injector;
-    constructor(http: HttpClient, settings: ODataSettings, injector: Injector);
+    settings?: ODataSettings;
+    constructor(http: HttpClient, loader: ODataConfigLoader, injector: Injector);
     /**
      * Resolve the api for the given value.
      * Where value is: string type or an string name or an instance of resource.
@@ -19,6 +21,7 @@ export declare class ODataClient {
      * @returns The api for the value.
      */
     apiFor(value?: ODataResource<any> | string): ODataApi;
+    defaultApi(): ODataApi;
     /**
      * Resolve the parser for the given string type.
      * @param type The string type of the parser.

package/lib/index.d.ts

@@ -2,8 +2,8 @@ export * from './types';
 export * from './settings';
 export * from './api';
 export * from './client';
-export * from './tokens';
 export * from './module';
+export * from './loaders';
 export * from './utils/index';
 export * from './services/index';
 export * from './schema/index';

package/lib/loaders.d.ts

@@ -0,0 +1,15 @@
+import { Observable } from 'rxjs';
+import { ApiConfig } from './types';
+export declare abstract class ODataConfigLoader {
+    abstract loadConfigs(): Observable<ApiConfig[]>;
+}
+export declare class ODataConfigSyncLoader implements ODataConfigLoader {
+    private readonly passedConfigs;
+    constructor(passedConfigs: ApiConfig | ApiConfig[]);
+    loadConfigs(): Observable<ApiConfig[]>;
+}
+export declare class ODataConfigAsyncLoader implements ODataConfigLoader {
+    private readonly configs$;
+    constructor(configs$: Observable<ApiConfig> | Observable<ApiConfig>[] | Observable<ApiConfig[]>);
+    loadConfigs(): Observable<ApiConfig[]>;
+}

package/lib/models/model.d.ts

@@ -162,8 +162,8 @@ export declare class ODataModel<T> {
      * @returns The result of the context
      */
     asEntity<R>(ctx: (model: this) => R): R;
-    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', { ...options }?: {} & ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
+    callAction<P, R>(name: string, params: P | null, responseType?: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
     cast<S>(type: string): ODataModel<S>;
     fetchNavigationProperty<S>(name: keyof T | string, responseType: 'model' | 'collection', { ...options }?: {} & ODataQueryArgumentsOptions<S>): Observable<ODataModel<S> | ODataCollection<S, ODataModel<S>> | null>;
     getValue<P>(name: keyof T | string, options?: ODataOptions): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;

package/lib/models/options.d.ts

@@ -136,7 +136,7 @@ export declare class ODataModelField<F> {
             [name: string]: any;
         }[];
         reset?: boolean;
-    }): ODataModel<F> | ODataCollection<F, ODataModel<F>>;
+    }): ODataCollection<F, ODataModel<F>>;
 }
 export declare type ODataModelRelation<T> = {
     state: ODataModelState;

package/lib/module.d.ts

@@ -1,12 +1,18 @@
-import { ModuleWithProviders } from '@angular/core';
-import { ODataSettings } from './settings';
+import { InjectionToken, ModuleWithProviders, Provider } from '@angular/core';
+import { ODataConfigSyncLoader } from './loaders';
 import { ApiConfig } from './types';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/common/http";
-export declare function createSettings(configs: ApiConfig[]): ODataSettings;
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/common/http";
+export interface PassedInitialConfig {
+    config?: ApiConfig | ApiConfig[];
+    loader?: Provider;
+}
+export declare const ODATA_CONFIG: InjectionToken<ApiConfig>;
+export declare function createSyncLoader(passedConfig: PassedInitialConfig): ODataConfigSyncLoader;
 export declare class ODataModule {
-    static forRoot(...configs: ApiConfig[]): ModuleWithProviders<ODataModule>;
+    static forRoot(passedConfig: PassedInitialConfig): ModuleWithProviders<ODataModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ODataModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ODataModule, never, [typeof i1.HttpClientModule], never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ODataModule, never, [typeof i1.CommonModule, typeof i2.HttpClientModule], never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ODataModule>;
 }

package/lib/options.d.ts

@@ -20,6 +20,10 @@ export declare class ODataApiOptions implements ApiOptions {
      * Strip metadata from the response
      */
     stripMetadata: ODataMetadataType;
+    /**
+     * Use JSON Batch Format
+     */
+    jsonBatchFormat: boolean;
     /**
      * Cache fetch policy
      */

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

@@ -6,7 +6,7 @@ import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
 import { ODataEntities, ODataEntity, ODataProperty } from '../responses';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataNoneOptions, ODataOptions, ODataPropertyOptions } from './options';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
 export declare class ODataActionResource<P, R> extends ODataResource<R> {
     static factory<P, R>(api: ODataApi, { path, schema, segments, query, }: {
         path?: string;
@@ -26,7 +26,18 @@ export declare class ODataActionResource<P, R> extends ODataResource<R> {
     call(params: P | null, options?: ODataEntityOptions): Observable<ODataEntity<R>>;
     call(params: P | null, options?: ODataEntitiesOptions): Observable<ODataEntities<R>>;
     call(params: P | null, options?: ODataPropertyOptions): Observable<ODataProperty<R>>;
-    call(params: P | null, options?: ODataNoneOptions): Observable<null>;
+    call(params: P | null, options?: {
+        alias?: boolean;
+        responseType?: 'blob';
+    } & ODataOptions): Observable<Blob>;
+    call(params: P | null, options?: {
+        alias?: boolean;
+        responseType?: 'arraybuffer';
+    } & ODataOptions): Observable<ArrayBuffer>;
+    call(params: P | null, options?: {
+        alias?: boolean;
+        responseType?: 'none';
+    } & ODataOptions): Observable<null>;
     /**
      * Execute the action and return the result as a property
      * @param params Parameters for the action
@@ -62,4 +73,10 @@ export declare class ODataActionResource<P, R> extends ODataResource<R> {
      * @returns Observable of the result of the action
      */
     callCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(params: P | null, options?: ODataOptions): Observable<C | null>;
+    callArraybuffer(params: P | null, { alias, ...options }?: {
+        alias?: boolean;
+    } & ODataOptions): Observable<ArrayBuffer>;
+    callBlob(params: P | null, { alias, ...options }?: {
+        alias?: boolean;
+    } & ODataOptions): Observable<Blob>;
 }

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

@@ -7,8 +7,14 @@ import { ODataResponse } from '../responses';
 import { ODataOptions } from './options';
 export declare class ODataBatchRequest<T> extends Subject<HttpResponseBase> {
     request: ODataRequest<any>;
+    id: string;
+    group: string;
     constructor(request: ODataRequest<any>);
     toString(): string;
+    toLegacy(): string;
+    toJson(): {
+        [name: string]: any;
+    };
     onLoad(response: HttpResponseBase): void;
     onError(response: HttpErrorResponse): void;
 }
@@ -30,16 +36,21 @@ export declare class ODataBatchResource extends ODataResource<any> {
      * @param ctx The context for the request
      * @returns The result of execute the context
      */
-    add<R>(ctx: (batch: this) => Observable<R>): Observable<R>;
-    send(options?: ODataOptions): Observable<null | ODataResponse<string>>;
+    add<R>(ctx: (batch: this) => R): R;
+    send(options?: ODataOptions): Observable<ODataResponse<any>>;
+    private sendJson;
+    private sendLegacy;
     /**
      * Execute the batch request
      * @param ctx The context for the request
      * @param options The options of the batch request
      * @returns The result of execute the context
      */
-    exec<R>(ctx: (batch: this) => Observable<R>, options?: ODataOptions): Observable<R>;
+    exec<R>(ctx: (batch: this) => R, options?: ODataOptions): Observable<[R, ODataResponse<string>]>;
     body(): string;
-    static buildBody(batchBoundary: string, requests: ODataBatchRequest<any>[]): string;
-    static parseResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<string>): HttpResponseBase[];
+    json(): Object;
+    static buildLegacyBody(batchBoundary: string, requests: ODataBatchRequest<any>[]): string;
+    static buildJsonBody(requests: ODataBatchRequest<any>[]): Object;
+    static parseLegacyResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<string>): HttpResponseBase[];
+    static parseJsonResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<any>): HttpResponseBase[];
 }

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

@@ -7,7 +7,7 @@ import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
 import { ODataEntities, ODataEntity, ODataProperty } from '../responses';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataNoneOptions, ODataOptions, ODataPropertyOptions } from './options';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
 export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
     static factory<P, R>(api: ODataApi, { path, schema, segments, query, }: {
         path?: string;
@@ -42,7 +42,16 @@ export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
     } & ODataPropertyOptions): Observable<ODataProperty<R>>;
     call(params: P | null, options?: {
         alias?: boolean;
-    } & ODataNoneOptions): Observable<null>;
+        responseType?: 'blob';
+    } & ODataOptions): Observable<Blob>;
+    call(params: P | null, options?: {
+        alias?: boolean;
+        responseType?: 'arraybuffer';
+    } & ODataOptions): Observable<ArrayBuffer>;
+    call(params: P | null, options?: {
+        alias?: boolean;
+        responseType?: 'none';
+    } & ODataOptions): Observable<null>;
     /**
      * Execute the function with the given parameters and return the result as a property
      * @param params Parameters to be sent to the function
@@ -93,4 +102,10 @@ export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
     callCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(params: P | null, { alias, ...options }?: {
         alias?: boolean;
     } & ODataOptions): Observable<C | null>;
+    callArraybuffer(params: P | null, { alias, ...options }?: {
+        alias?: boolean;
+    } & ODataOptions): Observable<ArrayBuffer>;
+    callBlob(params: P | null, { alias, ...options }?: {
+        alias?: boolean;
+    } & ODataOptions): Observable<Blob>;
 }

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

@@ -24,9 +24,6 @@ export declare type ODataEntitiesOptions = ODataOptions & {
 export declare type ODataPropertyOptions = ODataOptions & {
     responseType?: 'property';
 };
-export declare type ODataNoneOptions = ODataOptions & {
-    responseType?: 'none';
-};
 export declare type ODataQueryArgumentsOptions<T> = ODataOptions & ODataQueryArguments<T>;
 export declare type ODataActionOptions<T> = ODataQueryArgumentsOptions<T>;
 export declare type ODataFunctionOptions<T> = ODataQueryArgumentsOptions<T> & {

package/lib/schema/parsers/structured-type.d.ts

@@ -100,7 +100,7 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     findChildParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): ODataStructuredTypeParser<any> | undefined;
     childParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): Parser<any>;
     deserialize(value: any, options?: ParserOptions): T;
-    serialize(value: T, options?: ParserOptions): any;
+    serialize(value: Partial<T>, options?: ParserOptions): any;
     encode(value: T, options?: ParserOptions): any;
     configure({ options, parserForType, findOptionsForType, }: {
         options: ParserOptions;

package/lib/settings.d.ts

@@ -7,7 +7,7 @@ import { ODataEntityService } from './services/entity';
 import { ApiConfig, Parser } from './types';
 export declare class ODataSettings {
     apis: ODataApi[];
-    constructor(...configs: ApiConfig[]);
+    constructor(configs: ApiConfig[]);
     configure(settings: {
         requester?: (request: ODataRequest<any>) => Observable<any>;
     }): void;

package/lib/types.d.ts

@@ -63,6 +63,7 @@ export interface ApiOptions {
     stringAsEnum?: boolean;
     deleteRefBy?: 'path' | 'id';
     nonParenthesisForEmptyParameterFunction?: boolean;
+    jsonBatchFormat?: boolean;
 }
 export interface ParserOptions {
     version?: ODataVersion;

package/lib/utils/enums.d.ts

@@ -1,8 +1,20 @@
 export declare const Enums: {
-    names<E>(Enum: E): string[];
-    values<E_1>(Enum: E_1): number[];
-    toValue<E_2>(Enum: E_2, value: any): number | undefined;
-    toValues<E_3>(Enum: E_3, value: any): number[];
-    toName<E_4>(Enum: E_4, value: any): string | undefined;
-    toNames<E_5>(Enum: E_5, value: any): string[];
+    names<E extends {
+        [key: string]: any;
+    }>(enums: E): string[];
+    values<E_1 extends {
+        [key: string]: any;
+    }>(enums: E_1): number[];
+    toValue<E_2 extends {
+        [key: string]: any;
+    }>(enums: E_2, value: any): number | undefined;
+    toValues<E_3 extends {
+        [key: string]: any;
+    }>(enums: E_3, value: any): number[];
+    toName<E_4 extends {
+        [key: string]: any;
+    }>(enums: E_4, value: any): string | undefined;
+    toNames<E_5 extends {
+        [key: string]: any;
+    }>(enums: E_5, value: any): string[];
 };

package/lib/utils/strings.d.ts

@@ -1,4 +1,7 @@
 export declare const Strings: {
-    uniqueId(prefix?: string, suffix?: string): string;
+    uniqueId({ prefix, suffix, }?: {
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+    }): string;
     titleCase(text: string): string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.115.0",
+  "version": "0.120.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {

package/esm2020/lib/tokens.mjs

@@ -1,3 +0,0 @@
-import { InjectionToken } from '@angular/core';
-export const ODATA_CONFIGURATIONS = new InjectionToken('odata.configuraions');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1vZGF0YS9zcmMvbGliL3Rva2Vucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLElBQUksY0FBYyxDQUNwRCxxQkFBcUIsQ0FDdEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFwaUNvbmZpZyB9IGZyb20gJy4vdHlwZXMnO1xuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNvbnN0IE9EQVRBX0NPTkZJR1VSQVRJT05TID0gbmV3IEluamVjdGlvblRva2VuPEFwaUNvbmZpZz4oXG4gICdvZGF0YS5jb25maWd1cmFpb25zJ1xuKTtcbiJdfQ==

package/lib/tokens.d.ts

@@ -1,3 +0,0 @@
-import { ApiConfig } from './types';
-import { InjectionToken } from '@angular/core';
-export declare const ODATA_CONFIGURATIONS: InjectionToken<ApiConfig>;