@opra/client 0.25.5 → 0.26.1

package/cjs/client.js

@@ -1,268 +1,83 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraHttpClient = void 0;
-const rxjs_1 = require("rxjs");
-const isReadableStreamLike_1 = require("rxjs/internal/util/isReadableStreamLike");
 const common_1 = require("@opra/common");
-const client_error_js_1 = require("./client-error.js");
-const collection_node_js_1 = require("./collection-node.js");
 const constants_js_1 = require("./constants.js");
-const http_request_js_1 = require("./http-request.js");
-const http_response_js_1 = require("./http-response.js");
-const singleton_node_js_1 = require("./singleton-node.js");
-const types_js_1 = require("./types.js");
-const kAssets = Symbol('kAssets');
+const collection_node_js_1 = require("./impl/collection-node.js");
+const http_request_observable_js_1 = require("./impl/http-request-observable.js");
+const http_response_js_1 = require("./impl/http-response.js");
+const singleton_node_js_1 = require("./impl/singleton-node.js");
 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 http_response_js_1.HttpResponse(init)
+        };
+        Object.defineProperty(this, constants_js_1.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[constants_js_1.kContext].serviceUrl;
+    }
+    get api() {
+        return this[constants_js_1.kContext].api;
+    }
+    get defaults() {
+        return this[constants_js_1.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 = (0, rxjs_1.lastValueFrom)(this._sendRequest(types_js_1.HttpObserveType.Body, new http_request_js_1.HttpRequest({
+        const controller = new http_request_observable_js_1.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 common_1.DocumentFactory.createDocument(body);
-            this[kAssets].api = api;
+            const api = await common_1.ApiDocumentFactory.createDocument(body);
+            this[constants_js_1.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 collection_node_js_1.HttpCollectionNode(ctx);
+    collection(path) {
+        return new collection_node_js_1.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 singleton_node_js_1.HttpSingletonNode(ctx);
+    singleton(path) {
+        return new singleton_node_js_1.HttpSingletonNode(this, path);
     }
-    _sendRequest(observe, request, sourceKind, endpoint, ctx) {
-        return new rxjs_1.Observable(subscriber => {
-            (async () => {
-                request.inset(this.defaults);
-                const url = new common_1.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 ((0, isReadableStreamLike_1.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 ((0, common_1.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 === types_js_1.HttpObserveType.Events)
-                    subscriber.next({
-                        observe,
-                        request,
-                        event: types_js_1.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 http_request_observable_js_1.HttpRequestObservable(this, {
+            method: 'GET',
+            url: path
         });
-    }
-    _fetch(url, init = {}) {
-        return fetch(url, init);
-    }
-    _createResponse(init) {
-        return new http_response_js_1.HttpResponse(init);
-    }
-    async _handleResponse(observe, subscriber, request, fetchResponse, sourceKind, endpoint, ctx) {
-        const headers = fetchResponse.headers;
-        if (observe === types_js_1.HttpObserveType.Events) {
-            const response = this._createResponse({
-                url: fetchResponse.url,
-                headers,
-                status: fetchResponse.status,
-                statusText: fetchResponse.statusText,
-                hasBody: !!fetchResponse.body
-            });
-            subscriber.next({
-                observe,
-                request,
-                event: types_js_1.HttpEventType.ResponseHeader,
-                response
-            });
-        }
-        let body;
-        let totalCount;
-        let affected;
-        const contentType = headers.get('Content-Type') || '';
-        if (fetchResponse.body) {
-            if (constants_js_1.JSON_CONTENT_TYPE_PATTERN.test(contentType)) {
-                body = await fetchResponse.json();
-                if (typeof body === 'string')
-                    body = JSON.parse(body);
-                if (constants_js_1.OPRA_JSON_CONTENT_TYPE_PATTERN.test(contentType)) {
-                    totalCount = body.totalCount;
-                    affected = body.affected;
-                }
-            }
-            else if (constants_js_1.TEXT_CONTENT_TYPE_PATTERN.test(headers.get('Content-Type') || ''))
-                body = await fetchResponse.text();
-            else if (constants_js_1.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 === types_js_1.HttpObserveType.Body && fetchResponse.status >= 400 && fetchResponse.status < 600) {
-            subscriber.error(new client_error_js_1.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 === types_js_1.HttpObserveType.Body) {
-            if (constants_js_1.OPRA_JSON_CONTENT_TYPE_PATTERN.test(contentType))
-                subscriber.next(body.data);
-            else
-                subscriber.next(body);
-        }
-        else {
-            if (observe === types_js_1.HttpObserveType.Events)
-                subscriber.next({
-                    observe,
-                    request,
-                    event: types_js_1.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;
     }
 }
 exports.OpraHttpClient = OpraHttpClient;
-OpraHttpClient.kAssets = kAssets;

package/cjs/constants.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.kContext = exports.kRequest = exports.FORMDATA_CONTENT_TYPE_PATTERN = exports.TEXT_CONTENT_TYPE_PATTERN = exports.JSON_CONTENT_TYPE_PATTERN = exports.OPRA_JSON_CONTENT_TYPE_PATTERN = void 0;
+exports.kContext = exports.kClient = exports.FORMDATA_CONTENT_TYPE_PATTERN = exports.TEXT_CONTENT_TYPE_PATTERN = exports.JSON_CONTENT_TYPE_PATTERN = exports.OPRA_JSON_CONTENT_TYPE_PATTERN = void 0;
 exports.OPRA_JSON_CONTENT_TYPE_PATTERN = /^application\/\bopra\+json\b/i;
 exports.JSON_CONTENT_TYPE_PATTERN = /^application\/([\w-]+\+)?\bjson\b/i;
 exports.TEXT_CONTENT_TYPE_PATTERN = /^text\/.*$/i;
 exports.FORMDATA_CONTENT_TYPE_PATTERN = /^multipart\/\bform-data\b/i;
-exports.kRequest = Symbol.for('kRequest');
+exports.kClient = Symbol.for('kClient');
 exports.kContext = Symbol.for('kContext');

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpObserveType = void 0;
+var HttpObserveType;
+(function (HttpObserveType) {
+    HttpObserveType["ResponseHeader"] = "response-header";
+    HttpObserveType["Response"] = "response";
+    HttpObserveType["Body"] = "body";
+    HttpObserveType["Events"] = "events";
+})(HttpObserveType || (exports.HttpObserveType = HttpObserveType = {}));

package/cjs/enums/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./http-observable-type.enum.js"), exports);

package/cjs/impl/collection-node.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCollectionNode = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+const common_1 = require("@opra/common");
+const http_request_observable_js_1 = require("./http-request-observable.js");
+/**
+ * @class HttpCollectionNode
+ */
+class HttpCollectionNode {
+    constructor(client, path) {
+        this._client = client;
+        this._path = path;
+    }
+    create(data, options) {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+            method: 'POST',
+            url: this._path,
+            body: data
+        });
+        if (options?.include)
+            observable.param('include', (0, putil_varhelpers_1.toArrayDef)(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', (0, putil_varhelpers_1.toArrayDef)(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', (0, putil_varhelpers_1.toArrayDef)(options.omit, []).join(','));
+        return observable;
+    }
+    delete(id) {
+        if (id == null || id === '')
+            throw new TypeError(`'id' argument must have a value`);
+        const url = new common_1.OpraURL();
+        url.join({ resource: this._path, key: id });
+        return new http_request_observable_js_1.HttpRequestObservable(this._client, {
+            method: 'DELETE',
+            url
+        });
+    }
+    deleteMany(options) {
+        const observable = new http_request_observable_js_1.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 common_1.OpraURL();
+        url.join({ resource: this._path, key: id });
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+            method: 'GET',
+            url
+        });
+        if (options?.include)
+            observable.param('include', (0, putil_varhelpers_1.toArrayDef)(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', (0, putil_varhelpers_1.toArrayDef)(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', (0, putil_varhelpers_1.toArrayDef)(options.omit, []).join(','));
+        return observable;
+    }
+    findMany(options) {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+            method: 'GET',
+            url: this._path
+        });
+        if (options?.include)
+            observable.param('include', (0, putil_varhelpers_1.toArrayDef)(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', (0, putil_varhelpers_1.toArrayDef)(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', (0, putil_varhelpers_1.toArrayDef)(options.omit, []).join(','));
+        if (options?.sort)
+            observable.param('sort', (0, putil_varhelpers_1.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 common_1.OpraURL();
+        url.join({ resource: this._path, key: id });
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+            method: 'PATCH',
+            url,
+            body: data
+        });
+        if (options?.include)
+            observable.param('include', (0, putil_varhelpers_1.toArrayDef)(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', (0, putil_varhelpers_1.toArrayDef)(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', (0, putil_varhelpers_1.toArrayDef)(options.omit, []).join(','));
+        return observable;
+    }
+    updateMany(data, options) {
+        const observable = new http_request_observable_js_1.HttpRequestObservable(this._client, {
+            method: 'PATCH',
+            url: this._path,
+            body: data
+        });
+        if (options?.filter)
+            observable.param('filter', String(options.filter));
+        return observable;
+    }
+}
+exports.HttpCollectionNode = HttpCollectionNode;