angular-odata 0.92.0 → 0.95.0

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

@@ -1,14 +1,17 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataEntityResource } from './entity';
-import { ODataOptions } from './options';
+import { QueryOptionNames } from '../../types';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataEntities, ODataEntity } from '../responses/types';
+import { ODataEntityResource } from './entity';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions } from './options';
 export declare class ODataReferenceResource<T> extends ODataResource<T> {
-    static factory<P>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions<P>): ODataReferenceResource<P>;
-    clone(): ODataReferenceResource<T>;
-    schema(): undefined;
+    static factory<P>(api: ODataApi, { segments, query, }: {
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<P>;
+    }): ODataReferenceResource<P>;
     protected post(target: ODataEntityResource<any>, options?: ODataOptions): Observable<any>;
     protected put(target: ODataEntityResource<any>, options?: ODataOptions & {
         etag?: string;
@@ -48,4 +51,34 @@ export declare class ODataReferenceResource<T> extends ODataResource<T> {
     unset(options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
+    /**
+     * Fetch entity / entities
+     * @param options Options for the request
+     * @return An observable of the entity or entities with annotations
+     */
+    fetch(options?: ODataEntityOptions & {
+        etag?: string;
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<ODataEntity<T>>;
+    fetch(options?: ODataEntitiesOptions & {
+        etag?: string;
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<ODataEntities<T>>;
+    /**
+     * Fetch the entity
+     * @param options Options for the request
+     * @returns The entity
+     */
+    fetchEntity(options?: ODataOptions & {
+        etag?: string;
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<T | null>;
+    /**
+     * Fetch entities
+     * @param options Options for the request
+     * @returns The entities
+     */
+    fetchEntities(options?: ODataOptions & {
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<T[] | null>;
 }

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

@@ -1,26 +1,22 @@
-import { ODataResource } from '../resource';
-import { ODataEntity, ODataEntityAnnotations } from '../responses';
+import { Observable } from 'rxjs';
+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 { ODataApi } from '../../api';
 import { ODataFunctionResource } from './function';
-import { ODataModel } from '../../models';
 import { ODataNavigationPropertyResource } from './navigation-property';
 import { ODataOptions } from './options';
-import { ODataPathSegments } from '../path';
 import { ODataPropertyResource } from './property';
-import { ODataQueryOptions } from '../query';
-import { Observable } from 'rxjs';
 export declare class ODataSingletonResource<T> extends ODataResource<T> {
-    static factory<R>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions<R>): ODataSingletonResource<R>;
-    clone(): ODataSingletonResource<T>;
-    schema(): import("../../schema").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>;

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

@@ -1,13 +1,17 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataOptions } from './options';
+import { ODataStructuredType } from '../../schema/structured-type';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataOptions } from './options';
 export declare class ODataValueResource<T> extends ODataResource<T> {
-    static factory<V>(api: ODataApi, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions<V>): ODataValueResource<V>;
-    clone(): ODataValueResource<T>;
-    schema(): undefined;
+    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.

package/lib/schema/callable.d.ts

@@ -1,30 +1,14 @@
 import { CallableConfig, Options, Parser } from '../types';
+import { ODataSchemaElement } from './element';
 import { ODataCallableParser } from './parsers';
 import { ODataSchema } from './schema';
-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;
-    /**
-     * Returns a full type of the callable 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 callable 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;
-    get api(): import("angular-odata").ODataApi;
     configure({ parserForType, }: {
         parserForType: (type: string) => Parser<any>;
     }): void;

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,18 +1,8 @@
 import { EntityContainerConfig } from '../types';
-import { ODataAnnotatable } from './base';
+import { ODataSchemaElement } from './element';
 import { ODataEntitySet } from './entity-set';
 import { ODataSchema } from './schema';
-export declare class ODataEntityContainer extends ODataAnnotatable {
-    schema: ODataSchema;
-    name: string;
+export declare class ODataEntityContainer extends ODataSchemaElement {
     entitySets: ODataEntitySet[];
     constructor(config: EntityContainerConfig, 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.
-     */
-    titelize(term: string | RegExp): string;
 }

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

@@ -1,26 +1,10 @@
 import { EntitySetConfig } from '../types';
-import { ODataAnnotatable } from './base';
+import { ODataSchemaElement } from './element';
 import { ODataSchema } from './schema';
-export declare class ODataEntitySet extends ODataAnnotatable {
-    schema: ODataSchema;
-    name: string;
+export declare class ODataEntitySet extends ODataSchemaElement {
     entityType: string;
     service: {
         new (...params: any[]): any;
     };
     constructor(config: EntitySetConfig, schema: ODataSchema);
-    /**
-     * 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.
-     */
-    titelize(term: string | RegExp): string;
-    /**
-     * Returns a boolean indicating if the entity set 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;
-    get api(): import("angular-odata").ODataApi;
 }

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

@@ -1,10 +1,8 @@
 import { EnumTypeConfig, Options } from '../types';
+import { ODataSchemaElement } from './element';
 import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
-import { ODataAnnotatable } from './base';
 import { ODataSchema } from './schema';
-export declare class ODataEnumType<E> extends ODataAnnotatable {
-    schema: ODataSchema;
-    name: string;
+export declare class ODataEnumType<E> extends ODataSchemaElement {
     parser: ODataEnumTypeParser<E>;
     members: {
         [name: string]: number;
@@ -12,28 +10,6 @@ export declare class ODataEnumType<E> extends ODataAnnotatable {
         [value: number]: string;
     };
     constructor(config: EnumTypeConfig<E>, schema: ODataSchema);
-    /**
-     * 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.
-     */
-    titelize(term: string | RegExp): string;
-    /**
-     * Returns a full type of the enum 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 enum 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;
-    get api(): import("angular-odata").ODataApi;
     configure(): void;
     /**
      * Returns the fields of the enum type.

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

@@ -1,10 +1,10 @@
-import { ODataAnnotatable } from '../base';
-import { EnumTypeConfig, Parser, OptionsHelper, EnumTypeFieldConfig, Options } from '../../types';
+import { EnumTypeConfig, EnumTypeFieldConfig, Options, OptionsHelper, Parser } from '../../types';
+import { ODataAnnotatable } from '../annotation';
 export declare class ODataEnumTypeFieldParser extends ODataAnnotatable {
     name: string;
     value: number;
     constructor(name: string, field: EnumTypeFieldConfig);
-    titleize(term: string | RegExp): string;
+    titleize(term?: string | RegExp): string;
 }
 export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements Parser<T> {
     name: string;
@@ -25,7 +25,7 @@ export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements
      * @param term The term of the annotation to find.
      * @returns The titleized string.
      */
-    titelize(term: string | RegExp): string;
+    ttitelize(term?: string | RegExp): string;
     configure({ options }: {
         options: OptionsHelper;
     }): void;

package/lib/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 { ODataAnnotatable } from '../base';
 declare type JsonSchemaSelect<T> = Array<keyof T>;
 declare type JsonSchemaCustom<T> = {
     [P in keyof T]?: (schema: any, field: ODataStructuredTypeFieldParser<T[P]>) => any;
@@ -92,9 +92,9 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
      * @param term The term of the annotation to find.
      * @returns The titleized string.
      */
-    titelize(term: string | RegExp): 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;

package/lib/schema/schema.d.ts

@@ -1,6 +1,6 @@
-import { Parser, SchemaConfig } from '../types';
-import { ODataAnnotatable } from './base';
 import { ODataApi } from '../api';
+import { Parser, SchemaConfig } from '../types';
+import { ODataAnnotatable } from './annotation';
 import { ODataCallable } from './callable';
 import { ODataEntityContainer } from './entity-container';
 import { ODataEntitySet } from './entity-set';

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

@@ -1,12 +1,10 @@
-import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
-import { Options, StructuredTypeConfig } from '../types';
-import { ODataAnnotatable } from './base';
 import { ODataCollection } from '../models';
 import { ODataModel } from '../models/model';
+import { Options, StructuredTypeConfig } from '../types';
+import { ODataSchemaElement } from './element';
+import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
 import { ODataSchema } from './schema';
-export declare class ODataStructuredType<T> extends ODataAnnotatable {
-    name: string;
-    schema: ODataSchema;
+export declare class ODataStructuredType<T> extends ODataSchemaElement {
     base?: string;
     open: boolean;
     parent?: ODataStructuredType<any>;
@@ -15,32 +13,16 @@ export declare class ODataStructuredType<T> extends ODataAnnotatable {
     collection?: typeof ODataCollection;
     parser: ODataStructuredTypeParser<T>;
     constructor(config: StructuredTypeConfig<T>, schema: ODataSchema);
-    get api(): import("angular-odata").ODataApi;
     configure({ parserForType, findOptionsForType, }: {
         parserForType: (type: string) => any;
         findOptionsForType: (type: string) => any;
     }): void;
     /**
-     * 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.
-     */
-    titelize(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.
+     * 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
      */
-    isTypeOf(type: string): boolean;
+    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
@@ -56,7 +38,7 @@ export declare class ODataStructuredType<T> extends ODataAnnotatable {
      * @param name Name of the field
      * @returns The field parser
      */
-    findFieldByName<F>(name: keyof T): ODataStructuredTypeFieldParser<F>;
+    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.
@@ -68,7 +50,7 @@ export declare class ODataStructuredType<T> extends ODataAnnotatable {
      * @param field Field that belongs to the structured type
      * @returns The schema of the field
      */
-    findSchemaForField(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<any> | undefined;
+    findSchemaForField<E>(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<E>;
     /**
      * Returns all fields of the structured type.
      * @param include_navigation Include navigation properties in the result.

package/lib/services/base.d.ts

@@ -1,6 +1,6 @@
-import { ODataActionResource, ODataEntities, ODataEntity, ODataFunctionResource, ODataNavigationPropertyResource, ODataProperty, ODataQueryArgumentsOptions } 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;

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

@@ -1,8 +1,8 @@
-import { EntityKey, ODataEntities, ODataEntity, ODataEntityResource, ODataEntitySetResource, ODataOptions } from '../resources';
 import { Observable } from 'rxjs';
 import { ODataCollection } from '../models/collection';
-import { ODataEntityService } from './entity';
 import { ODataModel } from '../models/model';
+import { EntityKey, ODataEntities, ODataEntity, ODataEntityResource, ODataEntitySetResource, ODataOptions } from '../resources';
+import { ODataEntityService } from './entity';
 export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
     /**
      * Get the entity set resource for this service.

package/lib/services/entity.d.ts

@@ -1,6 +1,6 @@
+import { ODataModel } from '../models/model';
 import { EntityKey, ODataResource } from '../resources';
 import { ODataBaseService } from './base';
-import { ODataModel } from '../models/model';
 export declare abstract class ODataEntityService<T> extends ODataBaseService {
     abstract entity(key?: EntityKey<T>): ODataResource<T>;
     abstract attach<M extends ODataModel<T>>(value: M): void;

package/lib/services/singleton.d.ts

@@ -1,7 +1,7 @@
+import { Observable } from 'rxjs';
+import type { ODataModel } from '../models/model';
 import type { ODataEntity, ODataOptions, ODataSingletonResource } from '../resources';
 import { ODataEntityService } from './entity';
-import type { ODataModel } from '../models/model';
-import { Observable } from 'rxjs';
 /**
  * OData Singleton Service
  * www.odata.org/getting-started/advanced-tutorial/#singleton

package/lib/settings.d.ts

@@ -1,10 +1,10 @@
-import { ApiConfig, Parser } from './types';
-import { ODataCallable, ODataEntitySet, ODataEnumType, ODataStructuredType } from './schema';
-import { ODataCollection, ODataModel } from './models';
+import { Observable } from 'rxjs';
 import { ODataApi } from './api';
-import { ODataEntityService } from './services/entity';
+import { ODataCollection, ODataModel } from './models';
 import { ODataRequest } from './resources';
-import { Observable } from 'rxjs';
+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

@@ -63,6 +63,7 @@ export interface ApiOptions extends Options {
     stripMetadata?: ODataMetadataType;
     fetchPolicy?: FetchPolicy;
     bodyQueryOptions?: QueryOptionNames[];
+    deleteRefBy?: 'path' | 'id';
 }
 export interface OptionsHelper extends Options {
     helper: ODataVersionHelper;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.92.0",
+  "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
 }