angular-odata 0.78.1 → 0.95.0

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

@@ -1,12 +1,10 @@
 import { ODataCollection } from '../models';
 import { ODataModel } from '../models/model';
-import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from '../parsers';
 import { Options, StructuredTypeConfig } from '../types';
-import { ODataAnnotation } from './annotation';
+import { ODataSchemaElement } from './element';
+import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
 import { ODataSchema } from './schema';
-export declare class ODataStructuredType<T> {
-    name: string;
-    schema: ODataSchema;
+export declare class ODataStructuredType<T> extends ODataSchemaElement {
     base?: string;
     open: boolean;
     parent?: ODataStructuredType<any>;
@@ -14,47 +12,128 @@ export declare class ODataStructuredType<T> {
     model?: typeof ODataModel;
     collection?: typeof ODataCollection;
     parser: ODataStructuredTypeParser<T>;
-    annotations: ODataAnnotation[];
     constructor(config: StructuredTypeConfig<T>, schema: ODataSchema);
-    get api(): import("angular-odata").ODataApi;
     configure({ parserForType, findOptionsForType, }: {
         parserForType: (type: string) => any;
         findOptionsForType: (type: string) => any;
     }): void;
-    type({ alias }?: {
-        alias?: boolean;
-    }): string;
-    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: ODataStructuredType<any>): boolean;
+    /**
+     * Returns a boolean indicating if the structured type has a simple key.
+     * @returns True if the structured type has a simple key
+     */
     isSimpleKey(): boolean;
+    /**
+     * Returns a boolean indicating if the structured type has a compound key.
+     * @returns True if the structured type has a compound key.
+     */
     isCompoundKey(): boolean;
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
-    field(name: keyof T): ODataStructuredTypeFieldParser<any> | undefined;
-    fields({ include_navigation, include_parents, }?: {
-        include_parents?: boolean;
-        include_navigation?: boolean;
+    /**
+     * Find the field parser for the given field name.
+     * @param name Name of the field
+     * @returns The field parser
+     */
+    findFieldByName<F>(name: keyof T): ODataStructuredTypeFieldParser<F> | undefined;
+    /**
+     * Find a parent schema of the structured type.
+     * @param predicate Function for evaluate the schemas in the hierarchy.
+     * @returns The schema that matches the predicate.
+     */
+    findParentSchema(predicate: (p: ODataStructuredType<any>) => boolean): ODataStructuredType<any> | undefined;
+    /**
+     * Find a parent schema of the structured type for the given field.
+     * @param field Field that belongs to the structured type
+     * @returns The schema of the field
+     */
+    findSchemaForField<E>(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<E>;
+    /**
+     * Returns all fields of the structured type.
+     * @param include_navigation Include navigation properties in the result.
+     * @param include_parents Include the parent types in the result.
+     * @returns All fields of the structured type.
+     */
+    fields({ include_navigation, include_parents, }: {
+        include_parents: boolean;
+        include_navigation: boolean;
     }): ODataStructuredTypeFieldParser<any>[];
+    /**
+     * Returns the keys of the structured type.
+     * @param include_parents Include the parent fields
+     * @returns The keys of the structured type
+     */
     keys({ include_parents, }?: {
         include_parents?: boolean;
     }): ODataEntityTypeKey[];
-    pick(value: {
+    /**
+     * Picks the fields from attributes.
+     * @param attrs
+     * @param include_parents Include the parent fields
+     * @param include_navigation Include the navigation fields
+     * @param include_etag Include the etag field
+     * @returns The picked fields
+     */
+    pick(attrs: {
         [name: string]: any;
     }, { include_parents, include_navigation, include_etag, }?: {
         include_parents?: boolean;
         include_navigation?: boolean;
         include_etag?: boolean;
     }): Partial<T>;
+    /**
+     * Deseialize the given value from the structured type.
+     * @param value Value to deserialize
+     * @param options Options for deserialization
+     * @returns Deserialized value
+     */
     deserialize(value: any, options?: Options): T;
+    /**
+     * Serialize the given value for the structured type.
+     * @param value Value to serialize
+     * @param options Options for serialization
+     * @returns Serialized value
+     */
     serialize(value: T, options?: Options): any;
+    /**
+     * Encode the given value for the structured type.
+     * @param value Value to encode
+     * @param options Options for encoding
+     * @returns Encoded value
+     */
     encode(value: T, options?: Options): any;
+    /**
+     * Resolve the key of the structured type for the given value.
+     * @param attrs Attributes of the value
+     * @returns Resolved key
+     */
     resolveKey(attrs: T | {
         [name: string]: any;
     }): any;
+    /**
+     * Returns the defaults values for the structured type.
+     * @returns Default values for the structured type
+     */
     defaults(): {
         [name: string]: any;
     };
+    /**
+     * Convert the structured type to json schema
+     * @param options Options for json schema
+     * @returns Json Schema
+     */
     toJsonSchema(options?: JsonSchemaOptions<T>): any;
+    /**
+     * Validate the given value against the structured type.
+     * @param attrs Attributes of the value
+     * @param method Method to use for the process validation
+     * @returns Object with the errors
+     */
     validate(attrs: Partial<T>, { method, navigation, }?: {
-        method?: 'create' | 'update' | 'patch';
+        method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): {
         [name: string]: any;

package/lib/services/base.d.ts

@@ -1,20 +1,20 @@
-import { ODataActionResource, ODataFunctionResource, ODataNavigationPropertyResource, ODataEntity, ODataEntities, ODataProperty, HttpQueryOptions } from '../resources';
-import { ODataClient } from '../client';
 import { Observable } from 'rxjs';
+import { ODataClient } from '../client';
+import { ODataActionResource, ODataEntities, ODataEntity, ODataFunctionResource, ODataNavigationPropertyResource, ODataProperty, ODataQueryArgumentsOptions } from '../resources';
 export declare abstract class ODataBaseService {
     protected client: ODataClient;
     protected name: string;
     protected apiNameOrEntityType?: string | undefined;
     constructor(client: ODataClient, name: string, apiNameOrEntityType?: string | undefined);
     get api(): import("angular-odata").ODataApi;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entity', options?: HttpQueryOptions<R>): Observable<ODataEntity<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entities', options?: HttpQueryOptions<R>): Observable<ODataEntities<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'property', options?: HttpQueryOptions<R>): Observable<ODataProperty<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'none', options?: HttpQueryOptions<R>): Observable<null>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entity', options?: HttpQueryOptions<R>): Observable<ODataEntity<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entities', options?: HttpQueryOptions<R>): Observable<ODataEntities<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'property', options?: HttpQueryOptions<R>): Observable<ODataProperty<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'none', options?: HttpQueryOptions<R>): Observable<null>;
-    protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entity', options?: HttpQueryOptions<S>): Observable<ODataEntity<S>>;
-    protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entities', options?: HttpQueryOptions<S>): Observable<ODataEntities<S>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entity', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntity<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entities', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntities<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'property', options?: ODataQueryArgumentsOptions<R>): Observable<ODataProperty<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'none', options?: ODataQueryArgumentsOptions<R>): Observable<null>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entity', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntity<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entities', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntities<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'property', options?: ODataQueryArgumentsOptions<R>): Observable<ODataProperty<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'none', options?: ODataQueryArgumentsOptions<R>): Observable<null>;
+    protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entity', options?: ODataQueryArgumentsOptions<S>): Observable<ODataEntity<S>>;
+    protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entities', options?: ODataQueryArgumentsOptions<S>): Observable<ODataEntities<S>>;
 }

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

@@ -1,7 +1,7 @@
-import { EntityKey, ODataEntitySetResource, ODataEntityResource, HttpOptions, ODataEntity, ODataEntities } from '../resources';
+import { Observable } from 'rxjs';
 import { ODataCollection } from '../models/collection';
 import { ODataModel } from '../models/model';
-import { Observable } from 'rxjs';
+import { EntityKey, ODataEntities, ODataEntity, ODataEntityResource, ODataEntitySetResource, ODataOptions } from '../resources';
 import { ODataEntityService } from './entity';
 export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
     /**
@@ -19,18 +19,21 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      */
     attach<M extends ODataModel<T>>(model: M): void;
     attach<C extends ODataCollection<T, ODataModel<T>>>(model: C): void;
+    /**
+     * The schema for the entity set.
+     */
     get entitySetSchema(): import("angular-odata").ODataEntitySet | undefined;
     /**
      * Get all entities from the entity set.
      * @param options The options for the request.
      */
-    fetchAll(options?: HttpOptions): Observable<T[]>;
+    fetchAll(options?: ODataOptions): Observable<T[]>;
     /**
      * Get entities from the entity set.
      * @param withCount Get the count of the entities.
      * @param options The options for the request.
      */
-    fetchMany(options?: HttpOptions & {
+    fetchMany(options?: ODataOptions & {
         withCount?: boolean;
     }): Observable<ODataEntities<T>>;
     /**
@@ -39,7 +42,7 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      * @param etag The etag for the entity.
      * @param options The options for the request.
      */
-    fetchOne(key: EntityKey<T>, options?: HttpOptions & {
+    fetchOne(key: EntityKey<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
     /**
@@ -47,7 +50,7 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      * @param attrs The attributes for the entity.
      * @param options The options for the request.
      */
-    create(attrs: Partial<T>, options?: HttpOptions): Observable<ODataEntity<T>>;
+    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
     /**
      * Update an entity in the entity set.
      * @param key The entity key.
@@ -55,7 +58,7 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      * @param etag The etag for the entity.
      * @param options The options for the request.
      */
-    update(key: EntityKey<T>, attrs: Partial<T>, options?: HttpOptions & {
+    update(key: EntityKey<T>, attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
     /**
@@ -65,7 +68,7 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      * @param etag The etag for the entity.
      * @param options The options for the request.
      */
-    patch(key: EntityKey<T>, attrs: Partial<T>, options?: HttpOptions & {
+    modify(key: EntityKey<T>, attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
     /**
@@ -74,7 +77,7 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      * @param etag The etag for the entity.
      * @param options The options for the request.
      */
-    destroy(key: EntityKey<T>, options?: HttpOptions & {
+    destroy(key: EntityKey<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
     /**
@@ -86,7 +89,7 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      */
     fetchOrCreate(key: EntityKey<T>, attrs: Partial<T>, { etag, ...options }?: {
         etag?: string;
-    } & HttpOptions): Observable<ODataEntity<T>>;
+    } & ODataOptions): Observable<ODataEntity<T>>;
     /**
      * Save an entity in the entity set.
      * @param attrs The attributes for the entity.
@@ -96,6 +99,6 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      */
     save(attrs: Partial<T>, { etag, method, ...options }?: {
         etag?: string;
-        method?: 'create' | 'update' | 'patch';
-    } & HttpOptions): Observable<ODataEntity<T>>;
+        method?: 'create' | 'update' | 'modify';
+    } & ODataOptions): Observable<ODataEntity<T>>;
 }

package/lib/services/entity.d.ts

@@ -1,8 +1,11 @@
-import { EntityKey, ODataResource } from '../resources';
 import { ODataModel } from '../models/model';
+import { EntityKey, ODataResource } from '../resources';
 import { ODataBaseService } from './base';
 export declare abstract class ODataEntityService<T> extends ODataBaseService {
     abstract entity(key?: EntityKey<T>): ODataResource<T>;
     abstract attach<M extends ODataModel<T>>(value: M): void;
+    /**
+     * The schema for the structured type.
+     */
     get structuredTypeSchema(): import("angular-odata").ODataStructuredType<T> | undefined;
 }

package/lib/services/singleton.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import type { ODataModel } from '../models/model';
-import type { HttpOptions, ODataEntity, ODataSingletonResource } from '../resources';
+import type { ODataEntity, ODataOptions, ODataSingletonResource } from '../resources';
 import { ODataEntityService } from './entity';
 /**
  * OData Singleton Service
@@ -17,6 +17,9 @@ export declare class ODataSingletonService<T> extends ODataEntityService<T> {
      * @param model The model to attach.
      */
     attach<M extends ODataModel<T>>(model: M): void;
+    /**
+     * The schema for the singleton.
+     */
     get singletonSchema(): import("angular-odata").ODataEntitySet | undefined;
     /**
      * Update the singleton entity
@@ -24,7 +27,7 @@ export declare class ODataSingletonService<T> extends ODataEntityService<T> {
      * @param etag The etag for the entity.
      * @param options The options for the request.
      */
-    update(attrs: Partial<T>, options?: HttpOptions & {
+    update(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
     /**
@@ -33,7 +36,7 @@ export declare class ODataSingletonService<T> extends ODataEntityService<T> {
      * @param etag The etag for the entity.
      * @param options The options for the request.
      */
-    patch(attrs: Partial<T>, options?: HttpOptions & {
+    patch(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
 }

package/lib/settings.d.ts

@@ -1,10 +1,10 @@
-import { ApiConfig, Parser } from './types';
-import { ODataApi } from './api';
-import { ODataCallable, ODataEntitySet, ODataEnumType, ODataStructuredType } from './schema';
-import { ODataRequest } from './resources';
 import { Observable } from 'rxjs';
+import { ODataApi } from './api';
 import { ODataCollection, ODataModel } from './models';
+import { ODataRequest } from './resources';
+import { ODataCallable, ODataEntitySet, ODataEnumType, ODataStructuredType } from './schema';
 import { ODataEntityService } from './services/entity';
+import { ApiConfig, Parser } from './types';
 export declare class ODataSettings {
     apis: ODataApi[];
     constructor(...configs: ApiConfig[]);

package/lib/types.d.ts

@@ -1,5 +1,5 @@
-import { Observable } from 'rxjs';
 import { ODataVersionHelper } from './helper';
+import { Observable } from 'rxjs';
 export declare type ODataVersion = '2.0' | '3.0' | '4.0';
 export declare type FetchPolicy = 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
 export declare type ODataMetadataType = 'minimal' | 'full' | 'none';
@@ -45,8 +45,10 @@ export interface ApiOptions extends Options {
     };
     withCredentials?: boolean;
     accept?: {
+        exponentialDecimals?: boolean;
         metadata?: ODataMetadataType;
         ieee754Compatible?: boolean;
+        streaming?: boolean;
     };
     etag?: {
         ifMatch?: boolean;
@@ -61,9 +63,11 @@ export interface ApiOptions extends Options {
     stripMetadata?: ODataMetadataType;
     fetchPolicy?: FetchPolicy;
     bodyQueryOptions?: QueryOptionNames[];
+    deleteRefBy?: 'path' | 'id';
 }
 export interface OptionsHelper extends Options {
     helper: ODataVersionHelper;
+    exponentialDecimals?: boolean;
     metadata?: ODataMetadataType;
     ieee754Compatible?: boolean;
     streaming?: boolean;
@@ -77,8 +81,8 @@ export interface StructuredTypeFieldOptions extends OptionsHelper {
 }
 export interface Parser<T> {
     deserialize(value: any, options?: OptionsHelper | StructuredTypeFieldOptions): T;
-    serialize(value: T, options?: OptionsHelper | StructuredTypeFieldOptions): any;
-    encode(value: T, options?: OptionsHelper | StructuredTypeFieldOptions): any;
+    serialize(value: any, options?: OptionsHelper | StructuredTypeFieldOptions): any;
+    encode(value: any, options?: OptionsHelper | StructuredTypeFieldOptions): any;
 }
 export declare const NONE_PARSER: Parser<any>;
 export interface Cache {

package/lib/utils/arraybuffers.d.ts

@@ -0,0 +1,4 @@
+export declare const ArrayBuffers: {
+    toArrayBuffer(v: string): ArrayBuffer;
+    toString(v: ArrayBuffer): string;
+};

package/lib/{parsers/edm.d.ts → utils/durations.d.ts}

@@ -1,4 +1,3 @@
-import { Parser } from '../types';
 export declare type Duration = {
     sign?: 1 | -1;
     years?: number;
@@ -9,6 +8,7 @@ export declare type Duration = {
     minutes?: number;
     seconds?: number;
 };
-export declare const EDM_PARSERS: {
-    [type: string]: Parser<any>;
+export declare const Durations: {
+    toDuration(v: string): Duration;
+    toString(v: Duration): string;
 };

package/lib/utils/http.d.ts

@@ -7,7 +7,16 @@ export declare const Http: {
         [param: string]: string | string[];
     })[]): HttpParams;
     splitHttpParams(params: HttpParams, keys: string[]): [HttpParams, HttpParams];
+    withoutHttpParams(params: HttpParams, keys: string[]): HttpParams;
     resolveHeaderKey(headers: HttpHeaders | {
         [param: string]: string | string[];
     }, options: string[]): string | undefined;
+    headerValue(header: string): string;
+    parseResponseStatus(statusLine: string): {
+        status: string;
+        code: number;
+        message: string;
+    };
+    boundaryDelimiter(contentType: string): string;
+    boundaryEnd(boundaryDelimiter: string): string;
 };

package/lib/utils/index.d.ts

@@ -1,6 +1,9 @@
 export * from './dates';
+export * from './durations';
 export * from './enums';
-export * from './types';
+export * from './http';
 export * from './objects';
+export * from './odata';
+export * from './strings';
+export * from './types';
 export * from './urls';
-export * from './http';

package/lib/utils/objects.d.ts

@@ -16,8 +16,8 @@ export declare const Objects: {
     }): {
         [attr: string]: any;
     };
-    uniqueId: (str?: string) => string;
     resolveKey(key: any, { single }?: {
         single?: boolean | undefined;
     }): any;
+    clone(target: any, map?: WeakMap<object, any> | undefined): any;
 };

package/lib/utils/strings.d.ts

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

package/lib/utils/types.d.ts

@@ -1,8 +1,10 @@
 export declare const Types: {
+    rawType(value: any): string;
     isObject(value: any): boolean;
     isPlainObject(value: any): boolean;
     isFunction(value: any): boolean;
     isArray(value: any): boolean;
     isEmpty(value: any): boolean;
     isEqual(value1: any, value2: any): boolean;
+    clone(target: any): any;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.78.1",
+  "version": "0.95.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {
@@ -25,17 +25,30 @@
   "homepage": "https://github.com/diegomvh/angular-odata",
   "private": false,
   "peerDependencies": {
-    "@angular/common": "^12.2.0",
-    "@angular/core": "^12.2.0"
+    "@angular/common": "^13.1.0",
+    "@angular/core": "^13.1.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "main": "bundles/angular-odata.umd.js",
-  "module": "fesm2015/angular-odata.js",
-  "es2015": "fesm2015/angular-odata.js",
-  "esm2015": "esm2015/angular-odata.js",
-  "fesm2015": "fesm2015/angular-odata.js",
+  "module": "fesm2015/angular-odata.mjs",
+  "es2020": "fesm2020/angular-odata.mjs",
+  "esm2020": "esm2020/angular-odata.mjs",
+  "fesm2020": "fesm2020/angular-odata.mjs",
+  "fesm2015": "fesm2015/angular-odata.mjs",
   "typings": "angular-odata.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./angular-odata.d.ts",
+      "esm2020": "./esm2020/angular-odata.mjs",
+      "es2020": "./fesm2020/angular-odata.mjs",
+      "es2015": "./fesm2015/angular-odata.mjs",
+      "node": "./fesm2015/angular-odata.mjs",
+      "default": "./fesm2020/angular-odata.mjs"
+    }
+  },
   "sideEffects": false
 }