@opra/client 0.33.13 → 1.0.0-alpha.2

package/esm/http/http-client-base.js

@@ -1,88 +1,82 @@
-import { ApiDocumentFactory, ResponsiveMap } from '@opra/common';
+import { ApiDocumentFactory } from '@opra/common';
 import { kBackend } from '../constants.js';
-import { ClientBase } from '../core/client-base.js';
-import { HttpCollectionNode } from './http-collection-node.js';
 import { HttpRequestObservable } from './http-request-observable.js';
-import { HttpSingletonNode } from './http-singleton-node.js';
-import { HttpStorageNode } from './http-storage-node.js';
 /**
  *
  * @class OpraClientBase
  * @abstract
  */
-export class HttpClientBase extends ClientBase {
+export class HttpClientBase {
     constructor(backend) {
-        super(backend);
-        this._collectionCache = new ResponsiveMap();
-        this._singletonCache = new ResponsiveMap();
-        this._storageCache = new ResponsiveMap();
+        Object.defineProperty(this, kBackend, {
+            enumerable: false,
+            value: backend,
+        });
     }
     get serviceUrl() {
         return this[kBackend].serviceUrl;
     }
-    async getMetadata() {
-        if (this._metadataPromise)
-            return this._metadataPromise;
-        const request = new HttpRequestObservable(this[kBackend], {
-            method: 'GET',
-            url: '/',
-            headers: new Headers({ 'accept': 'application/json' })
-        });
-        let body;
-        try {
-            this._metadataPromise = request.getBody();
-            body = await this._metadataPromise;
-        }
-        catch (e) {
-            e.message = 'Error fetching metadata from url (' + this.serviceUrl + ').\n' + e.message;
-            throw e;
-        }
-        finally {
-            this._metadataPromise = undefined;
-        }
-        try {
-            const api = await ApiDocumentFactory.createDocument(body);
-            this[kBackend].api = api;
-            return api;
+    async getSchema() {
+        if (!this._schemaRequest) {
+            this._schemaRequest = this.request('$schema', {
+                headers: new Headers({ accept: 'application/json' }),
+            })
+                .getBody()
+                .catch(e => {
+                e.message = 'Error fetching api schema from url (' + this.serviceUrl + ').\n' + e.message;
+                throw e;
+            });
         }
-        catch (e) {
+        const body = await this._schemaRequest;
+        const document = await ApiDocumentFactory.createDocument(body).catch(e => {
             e.message = 'Error loading api document.\n' + e.message;
             throw e;
-        }
-    }
-    collection(path) {
-        let node = this._collectionCache.get(path);
-        if (!node) {
-            node = new HttpCollectionNode(this[kBackend], path);
-            this._collectionCache.set(path, node);
-        }
-        return node;
+        });
+        this[kBackend].document = document;
+        this._schemaRequest = undefined;
+        return document;
     }
-    singleton(path) {
-        let node = this._singletonCache.get(path);
-        if (!node) {
-            node = new HttpSingletonNode(this[kBackend], path);
-            this._singletonCache.set(path, node);
-        }
-        return node;
+    request(path, options) {
+        const observable = new HttpRequestObservable(this[kBackend], {
+            ...options,
+            method: options?.method || 'GET',
+            url: new URL(path, this.serviceUrl),
+        });
+        if (options?.params)
+            observable.param(options.params);
+        return observable;
     }
-    storage(path) {
-        let node = this._storageCache.get(path);
-        if (!node) {
-            node = new HttpStorageNode(this[kBackend], path);
-            this._storageCache.set(path, node);
-        }
-        return node;
+    delete(path, options) {
+        return this.request(path, {
+            ...options,
+            method: 'DELETE',
+        });
     }
-    action(path, params) {
-        const observable = new HttpRequestObservable(this[kBackend], {
+    get(path, options) {
+        return this.request(path, {
+            ...options,
             method: 'GET',
-            url: path
         });
-        if (params) {
-            Object.keys(params).forEach(k => params[k] = String(params[k]));
-            observable.param(params);
-        }
-        return observable;
+    }
+    patch(path, requestBody, options) {
+        return this.request(path, {
+            ...options,
+            method: 'PATCH',
+            body: requestBody,
+        });
+    }
+    post(path, requestBody, options) {
+        return this.request(path, {
+            ...options,
+            method: 'POST',
+            body: requestBody,
+        });
+    }
+    put(path, requestBody, options) {
+        return this.request(path, {
+            ...options,
+            method: 'PUT',
+            body: requestBody,
+        });
     }
 }

package/esm/http/http-interceptor-handler.js

@@ -1,12 +1,12 @@
 export class HttpInterceptorHandler {
     constructor(interceptors, finalHandler) {
         this.chain = interceptors.reduceRight((chainTailFn, interceptor) => (initialRequest, handler) => interceptor.intercept(initialRequest, {
-            handle: (downstreamRequest) => chainTailFn(downstreamRequest, handler)
+            handle: downstreamRequest => chainTailFn(downstreamRequest, handler),
         }), chainEnd);
         this.finalHandler = finalHandler;
     }
     handle(initialRequest) {
-        return this.chain(initialRequest, (req) => this.finalHandler.handle(req));
+        return this.chain(initialRequest, req => this.finalHandler.handle(req));
     }
 }
 function chainEnd(req, handler) {

package/esm/http/http-request-observable.js

@@ -1,6 +1,6 @@
 import { lastValueFrom, Observable } from 'rxjs';
 import typeIs from '@browsery/type-is';
-import { OpraURL } from '@opra/common';
+import { MimeTypes } from '@opra/common';
 import { kBackend, kContext } from '../constants.js';
 import { ClientError } from '../core/client-error.js';
 import { HttpObserveType } from './enums/http-observable-type.enum.js';
@@ -12,11 +12,9 @@ import { HttpEventType } from './interfaces/http-event.js';
  */
 export class HttpRequestObservable extends Observable {
     constructor(backend, init) {
-        super((subscriber) => {
+        super(subscriber => {
             const observe = this[kContext].observe;
-            new HttpInterceptorHandler(backend.interceptors || [], this[kBackend])
-                .handle(this[kContext])
-                .subscribe({
+            new HttpInterceptorHandler(backend.interceptors || [], this[kBackend]).handle(this[kContext]).subscribe({
                 next(event) {
                     if (observe === HttpObserveType.Events) {
                         subscriber.next(event);
@@ -34,12 +32,12 @@ export class HttpRequestObservable extends Observable {
                             subscriber.complete();
                             return;
                         }
-                        const isOpraResponse = typeIs.is(event.response.contentType || '', ['application/opra+json']);
+                        const isOpraResponse = typeIs.is(event.response.contentType || '', [MimeTypes.opra_response_json]);
                         if (response.status >= 400 && response.status < 600) {
                             subscriber.error(new ClientError({
                                 message: response.status + ' ' + response.statusText,
                                 status: response.status,
-                                issues: isOpraResponse ? response.body.errors : undefined
+                                issues: isOpraResponse ? response.body.errors : undefined,
                             }));
                             subscriber.complete();
                             return;
@@ -53,22 +51,20 @@ export class HttpRequestObservable extends Observable {
                 },
                 complete() {
                     subscriber.complete();
-                }
+                },
             });
         });
         Object.defineProperty(this, kBackend, {
             enumerable: false,
-            value: backend
+            value: backend,
         });
-        const url = new OpraURL(init?.url);
         Object.defineProperty(this, kContext, {
             enumerable: false,
             value: {
                 ...init,
                 observe: HttpObserveType.Body,
                 headers: new Headers(init?.headers),
-                url,
-            }
+            },
         });
     }
     clone() {
@@ -81,9 +77,7 @@ export class HttpRequestObservable extends Observable {
     header(arg0, value) {
         const target = this[kContext].headers;
         if (typeof arg0 === 'object') {
-            const h = arg0 instanceof Headers
-                ? arg0
-                : new Headers(arg0);
+            const h = arg0 instanceof Headers ? arg0 : new Headers(arg0);
             h.forEach((v, k) => {
                 if (k.toLowerCase() === 'set-cookie') {
                     target.append(k, v);
@@ -105,10 +99,12 @@ export class HttpRequestObservable extends Observable {
         }
         const target = this[kContext].url.searchParams;
         if (typeof arg0 === 'object') {
-            const h = arg0 instanceof URLSearchParams
-                ? arg0
-                : new URLSearchParams(arg0);
-            h.forEach((v, k) => target.set(k, v));
+            if (typeof arg0.forEach === 'function') {
+                arg0.forEach((v, k) => target.set(String(k), String(v)));
+            }
+            else {
+                Object.entries(arg0).forEach(entry => target.set(String(entry[0]), String(entry[1])));
+            }
             return this;
         }
         if (value == null)

package/esm/http/http-response.js

@@ -1,11 +1,11 @@
+/// <reference lib="dom" />
 export class HttpResponse {
     constructor(init) {
         /**
          * Returns true if response has body to be received
          */
         this.hasBody = false;
-        this.headers = init?.headers instanceof Headers ? init?.headers
-            : new Headers(init?.headers);
+        this.headers = init?.headers instanceof Headers ? init?.headers : new Headers(init?.headers);
         this.status = init?.status || 200;
         this.statusText = init?.statusText || 'OK';
         this.url = init?.url || null;

package/esm/http/http-utils.js

@@ -0,0 +1,8 @@
+export function urlPath(strings, ...values) {
+    let str = '';
+    let i;
+    for (i = 0; i < strings.length; i++) {
+        str += strings[0] + encodeURIComponent(values[i]);
+    }
+    return str;
+}

package/esm/index.js

@@ -1,16 +1,12 @@
-export * from './types.js';
 export * from './core/backend.js';
-export * from './core/client-base.js';
 export * from './core/client-error.js';
 export * from './http/fetch-backend.js';
 export * from './http/http-backend.js';
 export * from './http/http-client.js';
 export * from './http/http-client-base.js';
-export * from './http/http-collection-node.js';
 export * from './http/http-request-observable.js';
 export * from './http/http-response.js';
-export * from './http/http-singleton-node.js';
-export * from './http/http-storage-node.js';
+export * from './http/http-utils.js';
 export * from './http/enums/http-observable-type.enum.js';
 export * from './http/interfaces/http-event.js';
 export * from './http/interfaces/http-handler.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/client",
-  "version": "0.33.13",
+  "version": "1.0.0-alpha.2",
   "description": "Opra Client package",
   "author": "Panates",
   "license": "MIT",
@@ -19,6 +19,7 @@
     "postbuild": "cp README.md package.json ../../LICENSE ../../build/client && cp ../../package.cjs.json ../../build/client/cjs/package.json",
     "lint": "eslint . --max-warnings=0",
     "check": "madge --circular src/**",
+    "format": "prettier . --write --log-level=warn",
     "test": "jest",
     "cover": "jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
@@ -34,20 +35,20 @@
   "types": "./types/index.d.ts",
   "dependencies": {
     "@browsery/fs": "^0.4.0",
-    "@browsery/highland": "^0.6.0",
-    "@browsery/http-parser": "^0.4.0",
-    "@browsery/i18next": "^0.7.2",
-    "@browsery/stream": "^0.6.0",
-    "@browsery/type-is": "^0.6.3",
-    "@browsery/util": "^0.4.0",
-    "@opra/common": "^0.33.13",
+    "@browsery/highland": "^2.13.5",
+    "@browsery/http-parser": "^0.5.8",
+    "@browsery/i18next": "^23.8.2",
+    "@browsery/stream": "^4.3.0",
+    "@browsery/type-is": "^1.6.18-r2",
+    "@browsery/util": "^0.12.5",
+    "@opra/common": "^1.0.0-alpha.2",
     "accepts": "^1.3.8",
     "buffer": "^6.0.3",
     "cookie": "^0.6.0",
     "crypto-browserify": "^3.12.0",
-    "encodeurl": "^1.0.2",
+    "encodeurl": "^2.0.0",
     "events": "^3.3.0",
-    "fast-tokenizer": "^1.2.2",
+    "fast-tokenizer": "^1.3.0",
     "lodash.omit": "^4.5.0",
     "path-browserify": "^1.0.1",
     "process": "^0.11.10",
@@ -55,8 +56,9 @@
     "putil-merge": "^3.12.1",
     "putil-promisify": "^1.10.1",
     "putil-varhelpers": "^1.6.5",
-    "reflect-metadata": "^0.1.14",
+    "reflect-metadata": "^0.2.2",
     "rxjs": ">=7.0.0",
+    "ts-gems": "^3.4.0",
     "ts-lib": "^0.0.5",
     "uid": "^2.0.1"
   },
@@ -78,4 +80,4 @@
     "request",
     "fetch"
   ]
-}
+}

package/types/core/backend.d.ts

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { ApiDocument } from '@opra/common';
 import { HttpEvent } from '../http/interfaces/http-event.js';
 export declare abstract class Backend implements Backend {
-    api?: ApiDocument;
+    document?: ApiDocument;
     protected constructor(options?: Backend.Options);
     abstract handle(init: Backend.RequestInit): Observable<HttpEvent>;
 }
@@ -11,7 +11,7 @@ export declare abstract class Backend implements Backend {
  */
 export declare namespace Backend {
     interface Options {
-        api?: ApiDocument;
+        document?: ApiDocument;
     }
     interface RequestInit {
     }

package/types/http/http-backend.d.ts

@@ -1,4 +1,4 @@
-import { OpraURL } from '@opra/common';
+import { ApiDocument } from '@opra/common';
 import { Backend } from '../core/backend.js';
 import type { HttpHandler } from './interfaces/http-handler.js';
 import type { HttpInterceptor } from './interfaces/http-interceptor.js';
@@ -9,6 +9,7 @@ import type { HttpInterceptor } from './interfaces/http-interceptor.js';
 export declare abstract class HttpBackend extends Backend implements HttpHandler {
     readonly serviceUrl: string;
     interceptors: HttpInterceptor<any>[];
+    document?: ApiDocument;
     protected constructor(serviceUrl: string, options?: HttpBackend.Options);
 }
 /**
@@ -20,7 +21,7 @@ export declare namespace HttpBackend {
     }
     interface RequestInit extends Backend.RequestInit {
         method: string;
-        url: string | URL | OpraURL;
+        url: string | URL;
         headers?: Headers;
         body?: any;
     }

package/types/http/http-client-base.d.ts

@@ -1,36 +1,35 @@
-import { ApiDocument, ResponsiveMap } from '@opra/common';
+import { StrictOmit } from 'ts-gems';
+import { ApiDocument, URLSearchParamsInit } from '@opra/common';
 import { kBackend } from '../constants.js';
-import { ClientBase } from '../core/client-base.js';
 import { HttpBackend } from './http-backend.js';
-import { HttpCollectionNode } from './http-collection-node.js';
 import { HttpRequestObservable } from './http-request-observable.js';
-import { HttpSingletonNode } from './http-singleton-node.js';
-import { HttpStorageNode } from './http-storage-node.js';
 /**
  *
- * @class OpraClientBase
- * @abstract
+ * @namespace OpraClientBase
  */
-export declare abstract class HttpClientBase<TRequestOptions = {}, TResponseExt = {}> extends ClientBase {
-    [kBackend]: HttpBackend;
-    protected _collectionCache: ResponsiveMap<HttpCollectionNode<any, {}, {}>>;
-    protected _singletonCache: ResponsiveMap<HttpCollectionNode<any, {}, {}>>;
-    protected _storageCache: ResponsiveMap<HttpStorageNode<any, {}, {}>>;
-    protected _metadataPromise?: Promise<any>;
-    protected constructor(backend: HttpBackend);
-    get serviceUrl(): string;
-    getMetadata(): Promise<ApiDocument>;
-    collection<TType = any>(path: string): HttpCollectionNode<TType, TRequestOptions, TResponseExt>;
-    singleton<TType = any>(path: string): HttpSingletonNode<TType, TRequestOptions, TResponseExt>;
-    storage<TType = any>(path: string): HttpStorageNode<TType, TRequestOptions, TResponseExt>;
-    action<T = any>(path: string, params?: Record<string, any>): HttpRequestObservable<T, T, TRequestOptions, TResponseExt>;
+export declare namespace OpraClientBase {
+    interface Options {
+        document?: ApiDocument;
+    }
+    type RequestOptions = Partial<StrictOmit<HttpBackend.RequestInit, 'url'>> & {
+        params?: URLSearchParamsInit;
+    };
 }
 /**
  *
- * @namespace OpraClientBase
+ * @class OpraClientBase
+ * @abstract
  */
-export declare namespace OpraClientBase {
-    interface Options extends ClientBase.Options {
-        api?: ApiDocument;
-    }
+export declare abstract class HttpClientBase<TRequestOptions = {}, TResponseExt = {}> {
+    protected [kBackend]: HttpBackend;
+    protected _schemaRequest?: Promise<any>;
+    protected constructor(backend: HttpBackend);
+    get serviceUrl(): string;
+    getSchema(): Promise<ApiDocument>;
+    request<TBody = any>(path: string, options?: OpraClientBase.RequestOptions): HttpRequestObservable<TBody, TBody, TRequestOptions, TResponseExt>;
+    delete<TBody = any>(path: string, options?: StrictOmit<OpraClientBase.RequestOptions, 'method' | 'body'>): HttpRequestObservable<TBody, TBody, TRequestOptions, TResponseExt>;
+    get<TBody = any>(path: string, options?: StrictOmit<OpraClientBase.RequestOptions, 'method' | 'body'>): HttpRequestObservable<TBody, TBody, TRequestOptions, TResponseExt>;
+    patch<TBody = any>(path: string, requestBody: any, options?: StrictOmit<OpraClientBase.RequestOptions, 'method' | 'body'>): HttpRequestObservable<TBody, TBody, TRequestOptions, TResponseExt>;
+    post<TBody = any>(path: string, requestBody: any, options?: StrictOmit<OpraClientBase.RequestOptions, 'method' | 'body'>): HttpRequestObservable<TBody, TBody, TRequestOptions, TResponseExt>;
+    put<TBody = any>(path: string, requestBody: any, options?: StrictOmit<OpraClientBase.RequestOptions, 'method' | 'body'>): HttpRequestObservable<TBody, TBody, TRequestOptions, TResponseExt>;
 }

package/types/http/http-request-observable.d.ts

@@ -1,7 +1,6 @@
 import { Observable } from 'rxjs';
-import { OpraURL } from '@opra/common';
+import { URLSearchParamsInit } from '@opra/common';
 import { kBackend, kContext } from '../constants.js';
-import { URLSearchParamsInit } from '../types.js';
 import { HttpObserveType } from './enums/http-observable-type.enum.js';
 import { HttpBackend } from './http-backend.js';
 import { HttpResponse } from './http-response.js';
@@ -15,7 +14,7 @@ export declare class HttpRequestObservable<T, TBody = T, TRequestOptions = {}, T
     [kContext]: {
         observe: HttpObserveType;
         method: string;
-        url: OpraURL;
+        url: URL;
         headers: Headers;
         [key: string]: any;
     };
@@ -24,7 +23,7 @@ export declare class HttpRequestObservable<T, TBody = T, TRequestOptions = {}, T
     options(options: TRequestOptions): HttpRequestObservable<T, TBody, TRequestOptions, TResponseExt>;
     header(headers: HeadersInit): this;
     header(name: string, value?: string | number | boolean | null): this;
-    param(params: URLSearchParamsInit): this;
+    param(params: URLSearchParamsInit | Record<string, string | number | boolean | Date>): this;
     param(name: string, value: any): this;
     observe(observe: HttpObserveType.Body): HttpRequestObservable<TBody, TBody, TRequestOptions, TResponseExt>;
     observe(observe: HttpObserveType.ResponseHeader): HttpRequestObservable<HttpResponse<void> & TResponseExt, TBody, TRequestOptions, TResponseExt>;

package/types/http/http-response.d.ts

@@ -1,3 +1,4 @@
+/// <reference lib="dom" />
 export declare namespace HttpResponse {
     interface Initiator {
         headers?: HeadersInit;

package/types/http/http-utils.d.ts

@@ -0,0 +1 @@
+export declare function urlPath(strings: string[], ...values: any[]): string;

package/types/index.d.ts

@@ -1,16 +1,12 @@
-export * from './types.js';
 export * from './core/backend.js';
-export * from './core/client-base.js';
 export * from './core/client-error.js';
 export * from './http/fetch-backend.js';
 export * from './http/http-backend.js';
 export * from './http/http-client.js';
 export * from './http/http-client-base.js';
-export * from './http/http-collection-node.js';
 export * from './http/http-request-observable.js';
 export * from './http/http-response.js';
-export * from './http/http-singleton-node.js';
-export * from './http/http-storage-node.js';
+export * from './http/http-utils.js';
 export * from './http/enums/http-observable-type.enum.js';
 export * from './http/interfaces/http-event.js';
 export * from './http/interfaces/http-handler.js';

package/cjs/core/client-base.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientBase = void 0;
-const constants_js_1 = require("../constants.js");
-/**
- *
- * @class ClientBase
- * @abstract
- */
-class ClientBase {
-    constructor(backend) {
-        Object.defineProperty(this, constants_js_1.kBackend, {
-            enumerable: false,
-            value: backend
-        });
-    }
-}
-exports.ClientBase = ClientBase;