@opra/client 0.25.5 → 0.26.0

package/esm/client.js

@@ -1,264 +1,79 @@
-import { lastValueFrom, Observable } from 'rxjs';
-import { isReadableStreamLike } from 'rxjs/internal/util/isReadableStreamLike';
-import { DocumentFactory, isBlob, OpraURL } from '@opra/common';
-import { ClientError } from './client-error.js';
-import { HttpCollectionNode } from './collection-node.js';
-import { FORMDATA_CONTENT_TYPE_PATTERN, JSON_CONTENT_TYPE_PATTERN, OPRA_JSON_CONTENT_TYPE_PATTERN, TEXT_CONTENT_TYPE_PATTERN } from './constants.js';
-import { HttpRequest } from './http-request.js';
-import { HttpResponse } from './http-response.js';
-import { HttpSingletonNode } from './singleton-node.js';
-import { HttpEventType, HttpObserveType, } from './types.js';
-const kAssets = Symbol('kAssets');
+import { ApiDocumentFactory } from '@opra/common';
+import { kContext } from './constants.js';
+import { HttpCollectionNode } from './impl/collection-node.js';
+import { HttpRequestObservable } from './impl/http-request-observable.js';
+import { HttpResponse } from './impl/http-response.js';
+import { HttpSingletonNode } from './impl/singleton-node.js';
 export class OpraHttpClient {
     constructor(serviceUrl, options) {
-        Object.defineProperty(this, kAssets, {
+        const context = {
+            serviceUrl,
+            requestInterceptors: [...(options?.requestInterceptors || [])],
+            responseInterceptors: [...(options?.responseInterceptors || [])],
+            api: options?.api,
+            defaults: {
+                ...options?.defaults,
+                headers: options?.defaults?.headers instanceof Headers
+                    ? options?.defaults?.headers : new Headers(options?.defaults?.headers),
+                params: options?.defaults?.params instanceof URLSearchParams
+                    ? options?.defaults?.params : new URLSearchParams(options?.defaults?.params)
+            },
+            fetch,
+            createResponse: (init) => new HttpResponse(init)
+        };
+        Object.defineProperty(this, kContext, {
             enumerable: false,
-            value: {
-                serviceUrl,
-                api: options?.api,
-                requestInterceptors: options?.requestInterceptors || [],
-                responseInterceptors: options?.responseInterceptors || []
-            }
+            value: context
         });
-        this.defaults = {
-            ...options?.defaults,
-            headers: options?.defaults?.headers instanceof Headers
-                ? options?.defaults?.headers : new Headers(options?.defaults?.headers),
-            params: options?.defaults?.params instanceof URLSearchParams
-                ? options?.defaults?.params : new URLSearchParams(options?.defaults?.params)
-        };
     }
     get serviceUrl() {
-        return this[kAssets].serviceUrl;
+        return this[kContext].serviceUrl;
+    }
+    get api() {
+        return this[kContext].api;
+    }
+    get defaults() {
+        return this[kContext].defaults;
     }
     async getMetadata() {
-        if (this[kAssets].api)
-            return this[kAssets].api;
-        let promise = this[kAssets].metadataPromise;
-        if (promise) {
+        let promise = this._metadataPromise;
+        if (promise)
             return promise;
-        }
-        this[kAssets].metadataPromise = promise = lastValueFrom(this._sendRequest(HttpObserveType.Body, new HttpRequest({
+        const controller = new HttpRequestObservable(this, {
             method: 'GET',
             url: '',
-            headers: new Headers({ 'accept': 'application/json' })
-        })));
+            headers: { 'accept': 'application/json' }
+        });
+        this._metadataPromise = promise = controller.getData();
         return await promise
             .then(async (body) => {
             if (!body)
                 throw new Error(`No response returned.`);
-            const api = await DocumentFactory.createDocument(body);
-            this[kAssets].api = api;
+            const api = await ApiDocumentFactory.createDocument(body);
+            this[kContext].api = api;
             return api;
         })
             .catch((e) => {
             e.message = 'Unable to fetch metadata from service url (' + this.serviceUrl + '). ' + e.message;
             throw e;
         })
-            .finally(() => delete this[kAssets].metadataPromise);
+            .finally(() => delete this._metadataPromise);
     }
-    // batch(requests: HttpRequestHost<any>[]): BatchRequest {
-    // this._assertMetadata();
-    // return new BatchRequest(request => this._sendRequest('response', request, requests);
-    // }
-    collection(resourceName) {
-        // If name argument is a class, we extract name from the class
-        if (typeof resourceName === 'function')
-            resourceName = resourceName.name;
-        const ctx = {
-            client: this,
-            sourceKind: 'Collection',
-            endpoint: '',
-            resource: resourceName,
-            send: (observe, request) => this._sendRequest(observe, request, 'Collection', ctx.endpoint, ctx),
-            // requestInterceptors: [
-            //   // Validate resource exists and is a collection resource
-            //   async () => {
-            //     const metadata = await this.getMetadata();
-            //     metadata.getCollection(ctx.sourceName);
-            //   }
-            // ],
-            responseInterceptors: []
-        };
-        return new HttpCollectionNode(ctx);
+    collection(path) {
+        return new HttpCollectionNode(this, path);
     }
-    singleton(sourceName) {
-        // If name argument is a class, we extract name from the class
-        if (typeof sourceName === 'function')
-            sourceName = sourceName.name;
-        const ctx = {
-            client: this,
-            sourceKind: 'Singleton',
-            endpoint: '',
-            resource: sourceName,
-            send: (observe, request) => this._sendRequest(observe, request, 'Singleton', ctx.endpoint, ctx),
-            // requestInterceptors: [
-            //   // Validate resource exists and is a singleton resource
-            //   async () => {
-            //     const metadata = await this.getMetadata();
-            //     metadata.getSingleton(ctx.sourceName);
-            //   }
-            // ],
-            responseInterceptors: []
-        };
-        return new HttpSingletonNode(ctx);
+    singleton(path) {
+        return new HttpSingletonNode(this, path);
     }
-    _sendRequest(observe, request, sourceKind, endpoint, ctx) {
-        return new Observable(subscriber => {
-            (async () => {
-                request.inset(this.defaults);
-                const url = new OpraURL(request.url, this.serviceUrl);
-                let body;
-                if (request.body) {
-                    let contentType;
-                    if (typeof request.body === 'string' || typeof request.body === 'number' || typeof request.body === 'boolean') {
-                        contentType = 'text/plain;charset=UTF-8"';
-                        body = String(request.body);
-                        request.headers.delete('Content-Size');
-                        delete request.duplex;
-                    }
-                    else if (isReadableStreamLike(request.body)) {
-                        contentType = 'application/octet-stream';
-                        body = request.body;
-                        request.duplex = 'half';
-                    }
-                    else if (Buffer.isBuffer(request.body)) {
-                        contentType = 'application/octet-stream';
-                        body = request.body;
-                        request.headers.set('Content-Size', String(request.body.length));
-                        delete request.duplex;
-                    }
-                    else if (isBlob(request.body)) {
-                        contentType = request.body.type || 'application/octet-stream';
-                        body = request.body;
-                        request.headers.set('Content-Size', String(request.body.length));
-                        delete request.duplex;
-                    }
-                    else {
-                        contentType = 'application/json';
-                        body = JSON.stringify(request.body);
-                        request.headers.delete('Content-Size');
-                        delete request.duplex;
-                    }
-                    if (!request.headers.has('Content-Type') && contentType)
-                        request.headers.set('Content-Type', contentType);
-                    request.body = body;
-                }
-                if (ctx) {
-                    const requestInterceptors = [
-                        ...this[kAssets].requestInterceptors,
-                        ...(ctx.requestInterceptors || [])
-                    ];
-                    for (const interceptor of requestInterceptors) {
-                        await interceptor(ctx, request);
-                    }
-                }
-                if (observe === HttpObserveType.Events)
-                    subscriber.next({
-                        observe,
-                        request,
-                        event: HttpEventType.Sent,
-                    });
-                const response = await this._fetch(url.toString(), request);
-                await this._handleResponse(observe, subscriber, request, response, sourceKind, endpoint, ctx);
-            })().catch(error => subscriber.error(error));
+    action(path, params) {
+        const observable = new HttpRequestObservable(this, {
+            method: 'GET',
+            url: path
         });
-    }
-    _fetch(url, init = {}) {
-        return fetch(url, init);
-    }
-    _createResponse(init) {
-        return new HttpResponse(init);
-    }
-    async _handleResponse(observe, subscriber, request, fetchResponse, sourceKind, endpoint, ctx) {
-        const headers = fetchResponse.headers;
-        if (observe === HttpObserveType.Events) {
-            const response = this._createResponse({
-                url: fetchResponse.url,
-                headers,
-                status: fetchResponse.status,
-                statusText: fetchResponse.statusText,
-                hasBody: !!fetchResponse.body
-            });
-            subscriber.next({
-                observe,
-                request,
-                event: HttpEventType.ResponseHeader,
-                response
-            });
-        }
-        let body;
-        let totalCount;
-        let affected;
-        const contentType = headers.get('Content-Type') || '';
-        if (fetchResponse.body) {
-            if (JSON_CONTENT_TYPE_PATTERN.test(contentType)) {
-                body = await fetchResponse.json();
-                if (typeof body === 'string')
-                    body = JSON.parse(body);
-                if (OPRA_JSON_CONTENT_TYPE_PATTERN.test(contentType)) {
-                    totalCount = body.totalCount;
-                    affected = body.affected;
-                }
-            }
-            else if (TEXT_CONTENT_TYPE_PATTERN.test(headers.get('Content-Type') || ''))
-                body = await fetchResponse.text();
-            else if (FORMDATA_CONTENT_TYPE_PATTERN.test(headers.get('Content-Type') || ''))
-                body = await fetchResponse.formData();
-            else {
-                const buf = await fetchResponse.arrayBuffer();
-                if (buf.byteLength)
-                    body = buf;
-            }
-        }
-        if (observe === HttpObserveType.Body && fetchResponse.status >= 400 && fetchResponse.status < 600) {
-            subscriber.error(new ClientError({
-                message: fetchResponse.status + ' ' + fetchResponse.statusText,
-                status: fetchResponse.status,
-                issues: body?.errors
-            }));
-            subscriber.complete();
-            return;
-        }
-        const responseInit = {
-            url: fetchResponse.url,
-            headers,
-            status: fetchResponse.status,
-            statusText: fetchResponse.statusText,
-            body
-        };
-        if (totalCount != null)
-            responseInit.totalCount = totalCount;
-        if (affected != null)
-            responseInit.affected = affected;
-        const response = this._createResponse(responseInit);
-        if (ctx) {
-            const responseInterceptors = [
-                ...this[kAssets].responseInterceptors,
-                ...(ctx.responseInterceptors || [])
-            ];
-            for (const interceptor of responseInterceptors) {
-                await interceptor(ctx, observe, request);
-            }
-        }
-        if (observe === HttpObserveType.Body) {
-            if (OPRA_JSON_CONTENT_TYPE_PATTERN.test(contentType))
-                subscriber.next(body.data);
-            else
-                subscriber.next(body);
-        }
-        else {
-            if (observe === HttpObserveType.Events)
-                subscriber.next({
-                    observe,
-                    request,
-                    event: HttpEventType.Response,
-                    response
-                });
-            else
-                subscriber.next(response);
+        if (params) {
+            Object.keys(params).forEach(k => params[k] = String(params[k]));
+            observable.param(params);
         }
-        subscriber.complete();
+        return observable;
     }
 }
-OpraHttpClient.kAssets = kAssets;

package/esm/constants.js

@@ -2,5 +2,5 @@ export const OPRA_JSON_CONTENT_TYPE_PATTERN = /^application\/\bopra\+json\b/i;
 export const JSON_CONTENT_TYPE_PATTERN = /^application\/([\w-]+\+)?\bjson\b/i;
 export const TEXT_CONTENT_TYPE_PATTERN = /^text\/.*$/i;
 export const FORMDATA_CONTENT_TYPE_PATTERN = /^multipart\/\bform-data\b/i;
-export const kRequest = Symbol.for('kRequest');
+export const kClient = Symbol.for('kClient');
 export const kContext = Symbol.for('kContext');

package/esm/enums/http-observable-type.enum.js

@@ -0,0 +1,7 @@
+export var HttpObserveType;
+(function (HttpObserveType) {
+    HttpObserveType["ResponseHeader"] = "response-header";
+    HttpObserveType["Response"] = "response";
+    HttpObserveType["Body"] = "body";
+    HttpObserveType["Events"] = "events";
+})(HttpObserveType || (HttpObserveType = {}));

package/esm/enums/index.js

@@ -0,0 +1 @@
+export * from './http-observable-type.enum.js';

package/esm/impl/collection-node.js

@@ -0,0 +1,115 @@
+import { toArrayDef } from 'putil-varhelpers';
+import { OpraURL } from '@opra/common';
+import { HttpRequestObservable } from './http-request-observable.js';
+/**
+ * @class HttpCollectionNode
+ */
+export class HttpCollectionNode {
+    constructor(client, path) {
+        this._client = client;
+        this._path = path;
+    }
+    create(data, options) {
+        const observable = new HttpRequestObservable(this._client, {
+            method: 'POST',
+            url: this._path,
+            body: data
+        });
+        if (options?.include)
+            observable.param('include', toArrayDef(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', toArrayDef(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', toArrayDef(options.omit, []).join(','));
+        return observable;
+    }
+    delete(id) {
+        if (id == null || id === '')
+            throw new TypeError(`'id' argument must have a value`);
+        const url = new OpraURL();
+        url.join({ resource: this._path, key: id });
+        return new HttpRequestObservable(this._client, {
+            method: 'DELETE',
+            url
+        });
+    }
+    deleteMany(options) {
+        const observable = new HttpRequestObservable(this._client, {
+            method: 'DELETE',
+            url: this._path
+        });
+        if (options?.filter)
+            observable.param('filter', String(options.filter));
+        return observable;
+    }
+    get(id, options) {
+        if (id == null || id === '')
+            throw new TypeError(`'id' argument must have a value`);
+        const url = new OpraURL();
+        url.join({ resource: this._path, key: id });
+        const observable = new HttpRequestObservable(this._client, {
+            method: 'GET',
+            url
+        });
+        if (options?.include)
+            observable.param('include', toArrayDef(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', toArrayDef(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', toArrayDef(options.omit, []).join(','));
+        return observable;
+    }
+    findMany(options) {
+        const observable = new HttpRequestObservable(this._client, {
+            method: 'GET',
+            url: this._path
+        });
+        if (options?.include)
+            observable.param('include', toArrayDef(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', toArrayDef(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', toArrayDef(options.omit, []).join(','));
+        if (options?.sort)
+            observable.param('sort', toArrayDef(options.sort, []).join(','));
+        if (options?.filter)
+            observable.param('filter', String(options.filter));
+        if (options?.limit != null)
+            observable.param('limit', String(options.limit));
+        if (options?.skip != null)
+            observable.param('skip', String(options.skip));
+        if (options?.count != null)
+            observable.param('count', String(options.count));
+        if (options?.distinct != null)
+            observable.param('distinct', String(options.distinct));
+        return observable;
+    }
+    update(id, data, options) {
+        if (id == null)
+            throw new TypeError(`'id' argument must have a value`);
+        const url = new OpraURL();
+        url.join({ resource: this._path, key: id });
+        const observable = new HttpRequestObservable(this._client, {
+            method: 'PATCH',
+            url,
+            body: data
+        });
+        if (options?.include)
+            observable.param('include', toArrayDef(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', toArrayDef(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', toArrayDef(options.omit, []).join(','));
+        return observable;
+    }
+    updateMany(data, options) {
+        const observable = new HttpRequestObservable(this._client, {
+            method: 'PATCH',
+            url: this._path,
+            body: data
+        });
+        if (options?.filter)
+            observable.param('filter', String(options.filter));
+        return observable;
+    }
+}