angular-odata 0.101.0 → 0.102.0

package/lib/models/collection.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from '@angular/core';
 import { Observable } from 'rxjs';
-import { ODataEntitiesAnnotations, ODataEntitySetResource, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource } from '../resources';
+import { ODataActionOptions, ODataEntitiesAnnotations, ODataEntitySetResource, ODataFunctionOptions, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryOptionsHandler, ODataResource } from '../resources';
 import { ODataModel } from './model';
 import { ODataModelEntry, ODataModelEvent, ODataModelField } from './options';
 export declare class ODataCollection<T, M extends ODataModel<T>> implements Iterable<M> {
@@ -104,8 +104,8 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         silent?: boolean;
     }): void;
     query(func: (q: ODataQueryOptionsHandler<T>) => void): this;
-    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataQueryArgumentsOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataQueryArgumentsOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    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>;
     private _unlink;
     private _link;
     private _findEntry;

package/lib/models/model.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from '@angular/core';
 import { Observable } from 'rxjs';
-import { EntityKey, ODataEntityAnnotations, ODataEntityResource, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
+import { EntityKey, ODataActionOptions, ODataEntityAnnotations, ODataEntityResource, ODataFunctionOptions, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
 import { ODataStructuredType } from '../schema';
 import { ODataCollection } from './collection';
 import { ModelOptions, ODataModelEvent, ODataModelField, ODataModelOptions, ODataModelRelation } from './options';
@@ -137,7 +137,7 @@ export declare class ODataModel<T> {
      * Create an execution context for change the internal query of a resource
      * @param func Function to execute
      */
-    query(func: (q: ODataQueryOptionsHandler<T>) => void): this;
+    query(func: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
     /**
      * Perform a check on the internal state of the model and return true if the model is changed.
      * @param include_navigation Check in navigation properties
@@ -152,8 +152,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 }?: {} & ODataQueryArgumentsOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataQueryArgumentsOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    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>;
     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

@@ -10,10 +10,10 @@ export declare class ODataModelEvent<T> {
     value?: any;
     previous?: any;
     options?: any;
-    constructor(name: ODataModelEventType, { model, collection, previous, value, track, options, }?: {
+    constructor(name: ODataModelEventType, { model, collection, previous, value, field, options, }?: {
         model?: ODataModel<T>;
         collection?: ODataCollection<T, ODataModel<T>>;
-        track?: string | number;
+        field?: ODataModelField<any> | number;
         previous?: any;
         value?: any;
         options?: any;
@@ -22,9 +22,9 @@ export declare class ODataModelEvent<T> {
     stopPropagation(): void;
     chain: [
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
-        string | number | null
+        ODataModelField<any> | number | null
     ][];
-    push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, track: string | number): void;
+    push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, field: ODataModelField<any> | number): ODataModelEvent<T>;
     visited(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
     get path(): string;
     model?: ODataModel<T>;
@@ -162,8 +162,13 @@ export declare class ODataModelOptions<T> {
         schema: ODataStructuredType<T>;
     });
     get api(): import("angular-odata").ODataApi;
-    type(): string;
+    type({ alias }?: {
+        alias?: boolean;
+    }): string;
     isTypeOf(type: string): boolean;
+    isModelFor(entity: T | {
+        [name: string]: any;
+    }): boolean;
     findChildOptions(predicate: (options: ODataModelOptions<any>) => boolean): ODataModelOptions<any> | undefined;
     configure({ findOptionsForType, options, }: {
         findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
@@ -191,7 +196,7 @@ export declare class ODataModelOptions<T> {
         resource?: ODataResource<T>;
         annots?: ODataEntityAnnotations;
     }): void;
-    query(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T>, func: (q: ODataQueryOptionsHandler<T>) => void): ODataModel<T>;
+    query(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T>, func: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): ODataModel<T>;
     resolveKey(value: ODataModel<T> | T | {
         [name: string]: any;
     }, { field_mapping, resolve, }?: {

package/lib/resources/query/builder.d.ts

@@ -59,7 +59,7 @@ export declare type QueryCustomType = {
 };
 export declare type Value = string | Date | number | boolean | QueryCustomType;
 export declare const raw: (value: string) => QueryCustomType;
-export declare const alias: (value: any, name?: string | undefined) => QueryCustomType;
+export declare const alias: (value: any, name?: string) => QueryCustomType;
 export declare const duration: (value: string) => QueryCustomType;
 export declare const binary: (value: string) => QueryCustomType;
 export declare const isQueryCustomType: (value: any) => boolean;

package/lib/resources/query/handlers.d.ts

@@ -45,6 +45,9 @@ export declare class ODataQueryOptionHandler<T> {
      * @returns The value
      */
     at(index: number): any;
+    some(predicate: (value: any) => boolean): boolean;
+    every(predicate: (value: any) => boolean): boolean;
+    find(predicate: (value: any) => boolean): any;
     private assertObject;
     /**
      * Set the value for path in the managed odata query option.
@@ -86,6 +89,12 @@ export declare class ODataQueryOptionHandler<T> {
 export declare class ODataQueryOptionsHandler<T> {
     protected options: ODataQueryOptions<T>;
     constructor(options: ODataQueryOptions<T>);
+    /**
+     * Create a raw odata value
+     * @param value The value to raw
+     * @returns The raw value
+     */
+    raw(value: any): import("./builder").QueryCustomType;
     /**
      * Create a new odata alias parameter
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_ParameterAliases
@@ -94,6 +103,18 @@ export declare class ODataQueryOptionsHandler<T> {
      * @returns The alias
      */
     alias(value: any, name?: string): import("./builder").QueryCustomType;
+    /**
+     * Create a duration odata value
+     * @param value The value to duration
+     * @returns The duration value
+     */
+    duration(value: any): import("./builder").QueryCustomType;
+    /**
+     * Create a binary odata value
+     * @param value The value to binary
+     * @returns The binary value
+     */
+    binary(value: any): import("./builder").QueryCustomType;
     /**
      * Normalize the given value to a valid odata value
      * @param value The value to normalize
@@ -211,14 +232,22 @@ export declare class ODataQueryOptionsHandler<T> {
      * @param param0 skip or top or skiptoken
      */
     paging({ skip, skiptoken, top, }?: {
-        skip?: number;
-        skiptoken?: string;
-        top?: number;
+        skip?: number | null;
+        skiptoken?: string | null;
+        top?: number | null;
     }): void;
     /**
      * Shortcut for clear pagination by unset $top, $skip, $skiptoken.
      */
     clearPaging(): void;
+    /**
+     * Shortcut for clear query.
+     */
+    clear(): void;
+    /**
+     * Retrun the query.
+     */
+    query(): ODataQueryArguments<T>;
     /**
      * Apply the given query options to the current query.
      * @param query The query to be applied.

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

@@ -1,21 +1,23 @@
 import { QueryOptionNames } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
-import { Expression, FilterExpression, OrderByExpression, SearchExpression } from './expressions';
+import { ComputeExpression, Expression, FilterExpression, OrderByExpression, SearchExpression } from './expressions';
 import { ExpandExpression } from './expressions/expand';
 import { SelectExpression } from './expressions/select';
 import { ODataQueryOptionHandler } from './handlers';
 export declare type ODataQueryArguments<T> = {
-    [QueryOptionNames.select]?: Select<T> | SelectExpression<T>;
-    [QueryOptionNames.filter]?: Filter<T> | FilterExpression<T>;
-    [QueryOptionNames.search]?: string | SearchExpression<T>;
-    [QueryOptionNames.compute]?: string;
-    [QueryOptionNames.transform]?: Transform<T>;
-    [QueryOptionNames.orderBy]?: OrderBy<T> | OrderByExpression<T>;
-    [QueryOptionNames.top]?: number;
-    [QueryOptionNames.skip]?: number;
-    [QueryOptionNames.skiptoken]?: string;
-    [QueryOptionNames.expand]?: Expand<T> | ExpandExpression<T>;
-    [QueryOptionNames.format]?: string;
+    [QueryOptionNames.select]?: Select<T> | SelectExpression<T> | null;
+    [QueryOptionNames.expand]?: Expand<T> | ExpandExpression<T> | null;
+    [QueryOptionNames.compute]?: string | ComputeExpression<T> | null;
+    [QueryOptionNames.filter]?: Filter<T> | FilterExpression<T> | null;
+    [QueryOptionNames.search]?: string | SearchExpression<T> | null;
+    [QueryOptionNames.transform]?: Transform<T> | null;
+    [QueryOptionNames.orderBy]?: OrderBy<T> | OrderByExpression<T> | null;
+    [QueryOptionNames.top]?: number | null;
+    [QueryOptionNames.skip]?: number | null;
+    [QueryOptionNames.skiptoken]?: string | null;
+    [QueryOptionNames.format]?: string | null;
+    [QueryOptionNames.levels]?: number | 'max' | null;
+    [QueryOptionNames.count]?: boolean | null;
 };
 export declare class ODataQueryOptions<T> {
     values: Map<QueryOptionNames, any>;

package/lib/resources/request.d.ts

@@ -16,7 +16,6 @@ export declare class ODataRequest<T> {
     private readonly _headers;
     private readonly _params;
     private readonly _path;
-    private readonly _queryBody;
     constructor(init: {
         method: string;
         api: ODataApi;
@@ -45,6 +44,8 @@ export declare class ODataRequest<T> {
     get pathWithParams(): string;
     get url(): string;
     get urlWithParams(): string;
+    get cacheKey(): string;
+    isQueryBody(): boolean;
     isBatch(): boolean;
     isFetch(): boolean;
     isMutate(): boolean;

package/lib/resources/resource.d.ts

@@ -37,6 +37,7 @@ export declare class ODataResource<T> {
      * @returns boolean The resource has key ?
      */
     hasKey(): boolean;
+    hasEntityKey(): boolean;
     clearKey(): void | undefined;
     asModel<M extends ODataModel<T>>(entity?: Partial<T> | {
         [name: string]: any;
@@ -76,13 +77,13 @@ export declare class ODataResource<T> {
      * @param f Function context for handle the segments
      * @returns ODataActionResource
      */
-    segment(f: (q: ODataPathSegmentsHandler<T>) => void): this;
+    segment(f: (q: ODataPathSegmentsHandler<T>, s?: ODataStructuredType<T>) => void): this;
     /**
      * Handle the query options of the resource
      * Create an object handler for mutate the query options of the resource
      * @param f Function context for handle the query options
      */
-    query(f: (q: ODataQueryOptionsHandler<T>) => void): this;
+    query(f: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
     static resolveKey<T>(value: any, schema?: ODataStructuredType<T>): EntityKey<T> | undefined;
     protected resolveKey(value: any): EntityKey<T> | undefined;
     protected request(method: string, options: ODataOptions & {

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

@@ -25,6 +25,8 @@ export declare type ODataPropertyOptions = ODataOptions & {
 export declare type ODataNoneOptions = ODataOptions & {
     responseType?: 'none';
 };
-export declare type ODataQueryArgumentsOptions<T> = ODataQueryArguments<T> & {
+export declare type ODataQueryArgumentsOptions<T> = ODataOptions & ODataQueryArguments<T>;
+export declare type ODataActionOptions<T> = ODataQueryArgumentsOptions<T>;
+export declare type ODataFunctionOptions<T> = ODataQueryArgumentsOptions<T> & {
     alias?: boolean;
-} & ODataOptions;
+};

package/lib/services/base.d.ts

@@ -1,20 +1,20 @@
 import { Observable } from 'rxjs';
 import { ODataClient } from '../client';
-import { ODataActionResource, ODataEntities, ODataEntity, ODataFunctionResource, ODataNavigationPropertyResource, ODataProperty, ODataQueryArgumentsOptions } from '../resources';
+import { ODataActionOptions, ODataActionResource, ODataEntities, ODataEntity, ODataFunctionOptions, 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?: 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 callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entity', options?: ODataFunctionOptions<R>): Observable<ODataEntity<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entities', options?: ODataFunctionOptions<R>): Observable<ODataEntities<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'property', options?: ODataFunctionOptions<R>): Observable<ODataProperty<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'none', options?: ODataFunctionOptions<R>): Observable<null>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entity', options?: ODataActionOptions<R>): Observable<ODataEntity<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entities', options?: ODataActionOptions<R>): Observable<ODataEntities<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'property', options?: ODataActionOptions<R>): Observable<ODataProperty<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'none', options?: ODataActionOptions<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/utils/objects.d.ts

@@ -19,5 +19,5 @@ export declare const Objects: {
     resolveKey(key: any, { single }?: {
         single?: boolean | undefined;
     }): any;
-    clone(target: any, map?: WeakMap<object, any> | undefined): any;
+    clone(target: any, map?: WeakMap<object, any>): any;
 };

package/lib/utils/strings.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.101.0",
+  "version": "0.102.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {
@@ -25,8 +25,8 @@
   "homepage": "https://github.com/diegomvh/angular-odata",
   "private": false,
   "peerDependencies": {
-    "@angular/common": "^13.3.0",
-    "@angular/core": "^13.3.0"
+    "@angular/common": ">=13.0.0",
+    "@angular/core": ">=13.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"
@@ -36,13 +36,13 @@
   "esm2020": "esm2020/angular-odata.mjs",
   "fesm2020": "fesm2020/angular-odata.mjs",
   "fesm2015": "fesm2015/angular-odata.mjs",
-  "typings": "angular-odata.d.ts",
+  "typings": "index.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./angular-odata.d.ts",
+      "types": "./index.d.ts",
       "esm2020": "./esm2020/angular-odata.mjs",
       "es2020": "./fesm2020/angular-odata.mjs",
       "es2015": "./fesm2015/angular-odata.mjs",