angular-odata 0.99.2 → 0.100.1

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

@@ -7,9 +7,7 @@ import type { ODataQueryArguments, ODataQueryOptions } from './options';
 export declare class ODataQueryOptionHandler<T> {
     private o;
     private n;
-    constructor(o: {
-        [name: string]: any;
-    }, n: QueryOptionNames);
+    constructor(o: Map<QueryOptionNames, any>, n: QueryOptionNames);
     get name(): QueryOptionNames;
     toJSON(): any;
     empty(): boolean;
@@ -39,27 +37,33 @@ export declare class ODataQueryOptionsHandler<T> {
      * @returns The alias
      */
     alias(value: any, name?: string): import("./builder").QueryCustomType;
-    select(opts: (e: {
+    /**
+     * Normalize the given value to a valid odata value
+     * @param value The value to normalize
+     * @returns The normalized value
+     */
+    normalize(value: any): any;
+    select(opts: (builder: {
         s: T;
         e: () => SelectExpression<T>;
-    }) => SelectExpression<T>): SelectExpression<T>;
+    }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
     select(opts: Select<T>): ODataQueryOptionHandler<T>;
     select(): ODataQueryOptionHandler<T>;
-    expand(opts: (e: {
+    expand(opts: (builder: {
         s: T;
         e: () => ExpandExpression<T>;
-    }) => ExpandExpression<T>): ExpandExpression<T>;
+    }, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
     expand(opts: Expand<T>): ODataQueryOptionHandler<T>;
     expand(): ODataQueryOptionHandler<T>;
     /**
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptioncompute
      */
-    compute(opts: (e: {
+    compute(opts: (builder: {
         s: T;
         e: () => ComputeExpression<T>;
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
-    }) => ComputeExpression<T>): ComputeExpression<T>;
+    }, current?: ComputeExpression<T>) => ComputeExpression<T>): ComputeExpression<T>;
     compute(opts: string): ODataQueryOptionHandler<T>;
     compute(): ODataQueryOptionHandler<T>;
     /**
@@ -69,23 +73,23 @@ export declare class ODataQueryOptionsHandler<T> {
     format(): ODataQueryOptionHandler<T>;
     transform(opts: Transform<T>): ODataQueryOptionHandler<T>;
     transform(): ODataQueryOptionHandler<T>;
-    search(opts: (e: {
+    search(opts: (builder: {
         e: (connector: SearchConnector) => SearchExpression<T>;
-    }) => SearchExpression<T>): SearchExpression<T>;
+    }, current?: SearchExpression<T>) => SearchExpression<T>): SearchExpression<T>;
     search(opts: string): ODataQueryOptionHandler<T>;
     search(): ODataQueryOptionHandler<T>;
-    filter(opts: (e: {
+    filter(opts: (builder: {
         s: T;
         e: (connector?: FilterConnector) => FilterExpression<T>;
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
-    }) => FilterExpression<T>): FilterExpression<T>;
+    }, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
     filter(opts: Filter<T>): ODataQueryOptionHandler<T>;
     filter(): ODataQueryOptionHandler<T>;
-    orderBy(opts: (e: {
+    orderBy(opts: (builder: {
         s: T;
         e: () => OrderByExpression<T>;
-    }) => OrderByExpression<T>): OrderByExpression<T>;
+    }, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
     orderBy(opts: OrderBy<T>): ODataQueryOptionHandler<T>;
     orderBy(): ODataQueryOptionHandler<T>;
     top(opts: number): ODataQueryOptionHandler<T>;

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

@@ -1,25 +1,25 @@
 import { QueryOptionNames } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
-import { Expression } from './expressions';
+import { 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>;
-    [QueryOptionNames.filter]?: Filter<T>;
-    [QueryOptionNames.search]?: string;
+    [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>;
+    [QueryOptionNames.orderBy]?: OrderBy<T> | OrderByExpression<T>;
     [QueryOptionNames.top]?: number;
     [QueryOptionNames.skip]?: number;
     [QueryOptionNames.skiptoken]?: string;
-    [QueryOptionNames.expand]?: Expand<T>;
+    [QueryOptionNames.expand]?: Expand<T> | ExpandExpression<T>;
     [QueryOptionNames.format]?: string;
 };
 export declare class ODataQueryOptions<T> {
-    options: {
-        [name: string]: any;
-    };
-    constructor(options?: {
+    values: Map<QueryOptionNames, any>;
+    constructor(values?: Map<QueryOptionNames, any> | {
         [name: string]: any;
     });
     pathAndParams(escape?: boolean): [string, {
@@ -29,10 +29,10 @@ export declare class ODataQueryOptions<T> {
     toJSON(): {};
     toQueryArguments(): ODataQueryArguments<T>;
     clone<O>(): ODataQueryOptions<O>;
-    expression(name: QueryOptionNames, exp: Expression<T>): Expression<T>;
-    option<O>(name: QueryOptionNames, opts?: O): ODataQueryOptionHandler<O>;
-    has(name: QueryOptionNames): boolean;
-    remove(...names: QueryOptionNames[]): void;
-    keep(...names: QueryOptionNames[]): void;
+    expression(key: QueryOptionNames, exp?: Expression<T>): any;
+    option<O>(key: QueryOptionNames, opts?: O): ODataQueryOptionHandler<O>;
+    has(key: QueryOptionNames): boolean;
+    remove(...keys: QueryOptionNames[]): void;
+    keep(...keys: QueryOptionNames[]): void;
     clear(): void;
 }

package/lib/resources/resource.d.ts

@@ -59,6 +59,7 @@ export declare class ODataResource<T> {
     endpointUrl(params?: boolean): string;
     toString(): string;
     clone(): ODataResource<T>;
+    private __parser;
     deserialize(value: any, options?: OptionsHelper): any;
     serialize(value: any, options?: OptionsHelper): any;
     encode(value: any, options?: OptionsHelper): any;

package/lib/resources/responses/annotations.d.ts

@@ -2,35 +2,31 @@ import { ODataContext, ODataVersionHelper } from '../../helper';
 import { ODataMetadataType } from '../../types';
 export declare abstract class ODataAnnotations {
     helper: ODataVersionHelper;
-    protected annotations: {
-        [annot: string]: any;
-    };
+    protected annotations: Map<string, any>;
     protected context?: ODataContext | undefined;
-    constructor(helper: ODataVersionHelper, annotations?: {
-        [annot: string]: any;
-    }, context?: ODataContext | undefined);
+    constructor(helper: ODataVersionHelper, annotations?: Map<string, any>, context?: ODataContext | undefined);
     attributes<T>(data: {
-        [name: string]: any;
+        [key: string]: any;
     }, metadata: ODataMetadataType): T;
     get entitySet(): string | undefined;
     get type(): string | undefined;
     abstract clone(): ODataAnnotations;
     abstract data(data: {
-        [name: string]: any;
+        [key: string]: any;
     }): {
-        [name: string]: any;
+        [key: string]: any;
     };
 }
 export declare class ODataPropertyAnnotations extends ODataAnnotations {
     clone(): ODataPropertyAnnotations;
     data(data: {
-        [name: string]: any;
+        [key: string]: any;
     }): any;
 }
 export declare class ODataEntityAnnotations extends ODataAnnotations {
     clone(): ODataEntityAnnotations;
     data(data: {
-        [name: string]: any;
+        [key: string]: any;
     }): any;
     get id(): string | undefined;
     get etag(): string | undefined;
@@ -42,20 +38,18 @@ export declare class ODataEntityAnnotations extends ODataAnnotations {
     get mediaEditLink(): string | undefined;
     get mediaContentType(): string | undefined;
     private _properties?;
-    get properties(): {
-        [name: string]: any;
-    };
-    property(name: string): any;
+    get properties(): Map<string, Map<string, any>>;
+    property(name: string): Map<string, any> | undefined;
     private _functions?;
     get functions(): {
-        [name: string]: any;
+        [key: string]: any;
     };
     function(name: string): any;
 }
 export declare class ODataEntitiesAnnotations extends ODataAnnotations {
     clone(): ODataEntitiesAnnotations;
     data(data: {
-        [name: string]: any;
+        [key: string]: any;
     }): any;
     get readLink(): string | undefined;
     get count(): number | undefined;
@@ -66,7 +60,7 @@ export declare class ODataEntitiesAnnotations extends ODataAnnotations {
     get skiptoken(): string | undefined;
     private _functions?;
     get functions(): {
-        [name: string]: any;
+        [key: string]: any;
     };
     function(name: string): any;
 }

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

@@ -1,14 +1,13 @@
-import { ODataMetadataType, ODataVersion, Options, ResponseOptions } from '../../types';
+import { ODataMetadataType, ODataVersion, OptionsHelper, ResponseOptions } from '../../types';
 export declare class ODataResponseOptions implements ResponseOptions {
     version: ODataVersion;
     streaming?: boolean;
     metadata?: ODataMetadataType;
-    stringAsEnum?: boolean;
     ieee754Compatible?: boolean;
     location?: string;
     cacheability?: 'public' | 'private' | 'no-cache' | 'no-store';
     maxAge?: number;
-    constructor(config: Options);
+    constructor(config: OptionsHelper);
     get helper(): import("../../helper").ODataVersionHelper;
     clone(): ODataResponseOptions;
     setFeatures(features: string): void;

package/lib/resources/responses/response.d.ts

@@ -46,9 +46,7 @@ export declare class ODataResponse<T> extends HttpResponse<T> {
     private _context?;
     get context(): ODataContext;
     private _annotations?;
-    get annotations(): {
-        [name: string]: any;
-    };
+    get annotations(): Map<string, any>;
     /**
      * Handle the response body as an entity
      * @returns

package/lib/resources/types/entity-set.d.ts

@@ -40,7 +40,7 @@ export declare class ODataEntitySetResource<T> extends ODataResource<T> {
     fetchCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(options?: ODataOptions & {
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
-    }): Observable<ODataCollection<T, ODataModel<T>> | null>;
+    }): Observable<C | null>;
     fetchAll(options?: ODataOptions & {
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T[]>;

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

@@ -18,6 +18,9 @@ export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
     static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataFunctionResource<P, R>;
     clone(): ODataFunctionResource<P, R>;
     returnType(): string | undefined;
+    pathAndParams(escape?: boolean): [string, {
+        [name: string]: any;
+    }];
     parameters(params: P | null, { alias }?: {
         alias?: boolean;
     }): ODataFunctionResource<P, R>;

package/lib/schema/callable.d.ts

@@ -1,4 +1,4 @@
-import { CallableConfig, Options, Parser } from '../types';
+import { CallableConfig, OptionsHelper, Parser } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataCallableParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -18,21 +18,21 @@ export declare class ODataCallable<R> extends ODataSchemaElement {
      * @param options Options for deserialization
      * @returns Deserialized value
      */
-    deserialize(value: any, options?: Options): any;
+    deserialize(value: any, options?: OptionsHelper): 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;
+    serialize(value: any, options?: OptionsHelper): 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;
+    encode(value: any, options?: OptionsHelper): any;
     /**
      * Returns the binding parameter of the callable.
      * @returns The binding parameter of the callable.

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

@@ -1,4 +1,4 @@
-import { EnumTypeConfig, Options } from '../types';
+import { EnumTypeConfig, OptionsHelper } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -28,6 +28,12 @@ export declare class ODataEnumType<E> extends ODataSchemaElement {
      * @returns The field with the given value
      */
     findFieldByValue(value: number): ODataEnumTypeFieldParser | undefined;
+    /**
+     * Find a fields by flag.
+     * @param value The value of the field
+     * @returns The fields with the given flag
+     */
+    findFieldsByValue(value: number): ODataEnumTypeFieldParser[];
     /**
      * Map the fields of the enum type.
      * @param mapper Function that maps the value to the new value
@@ -40,19 +46,19 @@ export declare class ODataEnumType<E> extends ODataSchemaElement {
      * @param options Options for deserialization
      * @returns Deserialized value
      */
-    deserialize(value: any, options?: Options): E;
+    deserialize(value: any, options?: OptionsHelper): 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;
+    serialize(value: E, options?: OptionsHelper): 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;
+    encode(value: E, options?: OptionsHelper): any;
 }

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

@@ -1,4 +1,4 @@
-import { CallableConfig, Options, OptionsHelper, Parameter, Parser } from '../../types';
+import { CallableConfig, OptionsHelper, Parameter, Parser } from '../../types';
 import { ODataEnumTypeParser } from './enum-type';
 import { ODataStructuredTypeParser } from './structured-type';
 export declare class ODataParameterParser<T> {
@@ -9,8 +9,8 @@ export declare class ODataParameterParser<T> {
     nullable?: boolean;
     optionsHelper?: OptionsHelper;
     constructor(name: string, parameter: Parameter);
-    serialize(value: T, options?: Options): any;
-    encode(value: any, options?: Options): string;
+    serialize(value: T, options?: OptionsHelper): any;
+    encode(value: any, options?: OptionsHelper): string;
     configure({ parserForType, options, }: {
         parserForType: (type: string) => Parser<any>;
         options: OptionsHelper;
@@ -31,13 +31,15 @@ export declare class ODataCallableParser<R> implements Parser<R> {
     };
     parser: Parser<any>;
     parameters: ODataParameterParser<any>[];
+    nonParenthesisForEmptyParameterFunction?: boolean;
     optionsHelper?: OptionsHelper;
     constructor(config: CallableConfig, namespace: string, alias?: string);
     isTypeOf(type: string): boolean;
-    deserialize(value: any, options?: Options): R;
-    serialize(params: any, options?: Options): any;
-    encode(params: any, options?: Options): any;
-    configure({ parserForType, options, }: {
+    deserialize(value: any, options?: OptionsHelper): R;
+    serialize(params: any, options?: OptionsHelper): any;
+    encode(params: any, options?: OptionsHelper): any;
+    configure({ nonParenthesisForEmptyParameterFunction, parserForType, options, }: {
+        nonParenthesisForEmptyParameterFunction: boolean;
         parserForType: (type: string) => Parser<any>;
         options: OptionsHelper;
     }): void;

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

@@ -1,4 +1,4 @@
-import { EnumTypeConfig, EnumTypeFieldConfig, Options, OptionsHelper, Parser } from '../../types';
+import { EnumTypeConfig, EnumTypeFieldConfig, OptionsHelper, Parser } from '../../types';
 import { ODataAnnotatable } from '../annotation';
 export declare class ODataEnumTypeFieldParser extends ODataAnnotatable {
     name: string;
@@ -17,6 +17,7 @@ export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements
         [value: number]: string;
     };
     fields: ODataEnumTypeFieldParser[];
+    stringAsEnum?: boolean;
     optionsHelper?: OptionsHelper;
     constructor(config: EnumTypeConfig<T>, namespace: string, alias?: string);
     /**
@@ -26,13 +27,14 @@ export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements
      * @returns The titleized string.
      */
     ttitelize(term?: string | RegExp): string;
-    configure({ options }: {
+    configure({ stringAsEnum, options }: {
+        stringAsEnum: boolean;
         options: OptionsHelper;
     }): void;
     isTypeOf(type: string): boolean;
-    deserialize(value: string, options?: Options): T;
-    serialize(value: T, options?: Options): string;
-    encode(value: T, options?: Options): any;
+    deserialize(value: string, options?: OptionsHelper): T;
+    serialize(value: T, options?: OptionsHelper): string;
+    encode(value: T, options?: OptionsHelper): any;
     toJsonSchema(): any;
     validate(member: string | number, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';

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

@@ -1,4 +1,4 @@
-import { Options, OptionsHelper, Parser, StructuredTypeConfig, StructuredTypeFieldConfig } from '../../types';
+import { OptionsHelper, Parser, StructuredTypeConfig, StructuredTypeFieldConfig } from '../../types';
 import { ODataAnnotatable } from '../annotation';
 import { ODataEnumTypeParser } from './enum-type';
 declare type JsonSchemaSelect<T> = Array<keyof T>;
@@ -57,10 +57,10 @@ export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable
         [name: string]: any;
     }[] | string[] | undefined;
     private parse;
-    deserialize(value: any, options?: Options): T;
+    deserialize(value: any, options?: OptionsHelper): T;
     private toJson;
-    serialize(value: T, options?: Options): any;
-    encode(value: T, options?: Options): string;
+    serialize(value: T, options?: OptionsHelper): any;
+    encode(value: T, options?: OptionsHelper): string;
     configure({ parserForType, options, }: {
         parserForType: (type: string) => Parser<any>;
         options: OptionsHelper;
@@ -97,9 +97,9 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     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;
-    serialize(value: T, options?: Options): any;
-    encode(value: T, options?: Options): any;
+    deserialize(value: any, options?: OptionsHelper): T;
+    serialize(value: T, options?: OptionsHelper): any;
+    encode(value: T, options?: OptionsHelper): any;
     configure({ parserForType, options, }: {
         parserForType: (type: string) => Parser<any>;
         options: OptionsHelper;

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

@@ -1,6 +1,6 @@
 import { ODataCollection } from '../models';
 import { ODataModel } from '../models/model';
-import { Options, StructuredTypeConfig } from '../types';
+import { OptionsHelper, StructuredTypeConfig } from '../types';
 import { ODataSchemaElement } from './element';
 import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -96,21 +96,21 @@ export declare class ODataStructuredType<T> extends ODataSchemaElement {
      * @param options Options for deserialization
      * @returns Deserialized value
      */
-    deserialize(value: any, options?: Options): T;
+    deserialize(value: any, options?: OptionsHelper): 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;
+    serialize(value: T, options?: OptionsHelper): 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;
+    encode(value: T, options?: OptionsHelper): any;
     /**
      * Resolve the key of the structured type for the given value.
      * @param attrs Attributes of the value

package/lib/types.d.ts

@@ -30,13 +30,11 @@ export declare enum QueryOptionNames {
     skip = "skip",
     skiptoken = "skiptoken",
     format = "format",
+    levels = "levels",
     count = "count"
 }
-export interface Options {
+export interface ApiOptions {
     version?: ODataVersion;
-    stringAsEnum?: boolean;
-}
-export interface ApiOptions extends Options {
     params?: {
         [param: string]: string | string[];
     };
@@ -63,9 +61,12 @@ export interface ApiOptions extends Options {
     stripMetadata?: ODataMetadataType;
     fetchPolicy?: FetchPolicy;
     bodyQueryOptions?: QueryOptionNames[];
+    stringAsEnum?: boolean;
     deleteRefBy?: 'path' | 'id';
+    nonParenthesisForEmptyParameterFunction?: boolean;
 }
-export interface OptionsHelper extends Options {
+export interface OptionsHelper {
+    version?: ODataVersion;
     helper: ODataVersionHelper;
     exponentialDecimals?: boolean;
     metadata?: ODataMetadataType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.99.2",
+  "version": "0.100.1",
   "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.1.0",
-    "@angular/core": "^13.1.0"
+    "@angular/common": "^13.3.0",
+    "@angular/core": "^13.3.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"