@opra/client 0.4.0 → 0.6.0

package/cjs/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMDATA_CONTENT_TYPE_PATTERN = exports.TEXT_CONTENT_TYPE_PATTERN = exports.JSON_CONTENT_TYPE_PATTERN = void 0;
+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;

package/cjs/http/http-client.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpClient = void 0;
+const common_1 = require("@opra/common");
+const client_error_js_1 = require("../client-error.js");
+const constants_js_1 = require("../constants.js");
+const http_collection_service_js_1 = require("./http-collection-service.js");
+const http_singleton_service_js_1 = require("./http-singleton-service.js");
+const batch_request_js_1 = require("./requests/batch-request.js");
+const merge_raw_http_requests_util_js_1 = require("./utils/merge-raw-http-requests.util.js");
+const documentCache = new Map();
+const documentResolverCaches = new Map();
+class OpraHttpClient {
+    _serviceUrl;
+    _metadata;
+    defaults;
+    constructor(serviceUrl, options) {
+        this._serviceUrl = serviceUrl;
+        this._metadata = options?.document;
+        if (!this._metadata) {
+            const document = documentCache.get(this.serviceUrl.toLowerCase());
+            if (document)
+                this._metadata = document;
+        }
+        this.defaults = options?.defaults || {};
+    }
+    get serviceUrl() {
+        return this._serviceUrl;
+    }
+    get initialized() {
+        return !!this._metadata;
+    }
+    get metadata() {
+        this._assertMetadata();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this._metadata;
+    }
+    async init(forceRefresh) {
+        if (!forceRefresh && this.initialized)
+            return;
+        const cacheName = this.serviceUrl.toLowerCase();
+        let promise = documentResolverCaches.get(cacheName);
+        if (promise) {
+            await promise;
+            return;
+        }
+        promise = this._resolveMetadata();
+        documentResolverCaches.set(cacheName, promise);
+        return promise
+            .catch(() => void 0)
+            .finally(() => documentResolverCaches.delete(cacheName));
+    }
+    batch(requests) {
+        this._assertMetadata();
+        return new batch_request_js_1.BatchRequest(req => this._handleRequest(req), requests);
+    }
+    collection(name) {
+        this._assertMetadata();
+        // If name argument is a class, we extract name from the class
+        if (typeof name === 'function')
+            name = name.name;
+        const resource = this.metadata.getCollectionResource(name);
+        return new http_collection_service_js_1.HttpCollectionService(resource, req => this._handleRequest(req));
+    }
+    singleton(name) {
+        this._assertMetadata();
+        // If name argument is a class, we extract name from the class
+        if (typeof name === 'function')
+            name = name.name;
+        const resource = this.metadata.getSingletonResource(name);
+        return new http_singleton_service_js_1.HttpSingletonService(resource, req => this._handleRequest(req));
+    }
+    async _resolveMetadata() {
+        const resp = await this._handleRequest({
+            method: 'GET',
+            path: '/$metadata',
+            headers: { 'accept': 'application/json' }
+        });
+        this._metadata = new common_1.OpraDocument(resp.data);
+    }
+    async _handleRequest(req) {
+        (0, merge_raw_http_requests_util_js_1.mergeRawHttpRequests)(req, this.defaults);
+        let url = (0, common_1.joinPath)(this.serviceUrl, req.path);
+        if (req.params)
+            url += '?' + req.params.toString();
+        if (req.body) {
+            if (typeof req.body === 'object') {
+                if (!((0, common_1.isReadable)(req.body) || (0, common_1.isReadableStream)(req.body) || Buffer.isBuffer(req.body))) {
+                    if (!req.headers?.['content-type']) {
+                        req.headers = req.headers || {};
+                        req.headers['content-type'] = 'application/json';
+                    }
+                    req.body = JSON.stringify(req.body);
+                }
+            }
+        }
+        return this._fetch(url, req);
+    }
+    async _fetch(url, req) {
+        const resp = await fetch(url, req);
+        let data;
+        if (resp.body) {
+            if (constants_js_1.JSON_CONTENT_TYPE_PATTERN.test(resp.headers.get('Content-Type') || '')) {
+                data = await resp.json();
+                if (typeof data === 'string')
+                    data = JSON.parse(data);
+            }
+            else if (constants_js_1.TEXT_CONTENT_TYPE_PATTERN.test(resp.headers.get('Content-Type') || ''))
+                data = await resp.text();
+            else if (constants_js_1.FORMDATA_CONTENT_TYPE_PATTERN.test(resp.headers.get('Content-Type') || ''))
+                data = await resp.formData();
+            else
+                data = await resp.arrayBuffer();
+        }
+        if (resp.status >= 400 && resp.status < 600) {
+            throw new client_error_js_1.ClientError({
+                message: resp.status + ' ' + resp.statusText,
+                status: resp.status,
+                issues: data?.errors
+            });
+        }
+        const out = {
+            get headers() {
+                return resp.headers;
+            },
+            get ok() {
+                return resp.ok;
+            },
+            get redirected() {
+                return resp.redirected;
+            },
+            get status() {
+                return resp.status;
+            },
+            get statusText() {
+                return resp.statusText;
+            },
+            get type() {
+                return resp.type;
+            },
+            get url() {
+                return resp.url;
+            },
+            get contentId() {
+                return resp.headers.get('Content-ID');
+            },
+            get data() {
+                return data;
+            }
+        };
+        return out;
+    }
+    _assertMetadata() {
+        if (!this._metadata)
+            throw new Error('You must call init() to before using the client instance');
+    }
+    static async create(serviceUrl, options) {
+        const client = new this(serviceUrl, options);
+        if (!client._metadata)
+            await client.init();
+        return client;
+    }
+}
+exports.OpraHttpClient = OpraHttpClient;

package/cjs/http/http-collection-service.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCollectionService = void 0;
+const collection_create_request_js_1 = require("./requests/collection-create-request.js");
+const collection_delete_many_request_js_1 = require("./requests/collection-delete-many-request.js");
+const collection_delete_request_js_1 = require("./requests/collection-delete-request.js");
+const collection_get_request_js_1 = require("./requests/collection-get-request.js");
+const collection_search_request_js_1 = require("./requests/collection-search-request.js");
+const collection_update_many_request_js_1 = require("./requests/collection-update-many-request.js");
+const collection_update_request_js_1 = require("./requests/collection-update-request.js");
+class HttpCollectionService {
+    resource;
+    _handler;
+    constructor(resource, _handler) {
+        this.resource = resource;
+        this._handler = _handler;
+    }
+    create(data, options) {
+        return new collection_create_request_js_1.CollectionCreateRequest(this._handler, this.resource, data, options);
+    }
+    delete(keyValue, options) {
+        return new collection_delete_request_js_1.CollectionDeleteRequest(this._handler, this.resource, keyValue, options);
+    }
+    deleteMany(options) {
+        return new collection_delete_many_request_js_1.CollectionDeleteManyRequest(this._handler, this.resource, options);
+    }
+    get(keyValue, options) {
+        return new collection_get_request_js_1.CollectionGetRequest(this._handler, this.resource, keyValue, options);
+    }
+    search(options) {
+        return new collection_search_request_js_1.CollectionSearchRequest(this._handler, this.resource, options);
+    }
+    update(keyValue, data, options) {
+        return new collection_update_request_js_1.CollectionUpdateRequest(this._handler, this.resource, keyValue, data, options);
+    }
+    updateMany(data, options) {
+        return new collection_update_many_request_js_1.CollectionUpdateManyRequest(this._handler, this.resource, data, options);
+    }
+}
+exports.HttpCollectionService = HttpCollectionService;

package/cjs/http/http-request.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequest = void 0;
+const rxjs_1 = require("rxjs");
+const common_1 = require("@opra/common");
+class HttpRequest extends rxjs_1.Observable {
+    _handler;
+    options;
+    contentId;
+    _promise;
+    _headers;
+    constructor(_handler, options = {}) {
+        super((subscriber) => {
+            if (options.observe === 'response') {
+                this.fetch().then(v => {
+                    subscriber.next(v);
+                    subscriber.complete();
+                }).catch(e => subscriber.error(e));
+                return;
+            }
+            this.resolve().then(v => {
+                subscriber.next(v);
+                subscriber.complete();
+            }).catch(e => subscriber.error(e));
+        });
+        this._handler = _handler;
+        this.options = options;
+        this.contentId = (0, common_1.uid)(6);
+        this.options = options;
+    }
+    header(name, value) {
+        this._headers = this._headers || {};
+        this._headers[name] = value;
+        return this;
+    }
+    /**
+     * Sends the request
+     */
+    async fetch() {
+        const promise = this._promise || (this._promise = new Promise((resolve, reject) => {
+            setTimeout(() => {
+                this._execute().then(resolve).catch(reject);
+            }, 0);
+        }));
+        return await promise;
+    }
+    /**
+     * Sends the request and returns response data
+     */
+    async resolve() {
+        const resp = await this.fetch();
+        return resp.data;
+    }
+    with(cb) {
+        cb(this);
+        return this;
+    }
+    binding() {
+        return {};
+    }
+    async _execute() {
+        const req = this.prepare();
+        return await this._handler(req);
+    }
+}
+exports.HttpRequest = HttpRequest;

package/cjs/http/http-singleton-service.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpSingletonService = void 0;
+const http_singleton_get_request_js_1 = require("./requests/http-singleton-get-request.js");
+class HttpSingletonService {
+    resource;
+    _handler;
+    constructor(resource, _handler) {
+        this.resource = resource;
+        this._handler = _handler;
+    }
+    get(options) {
+        return new http_singleton_get_request_js_1.HttpSingletonGetRequest(this._handler, this.resource, options);
+    }
+}
+exports.HttpSingletonService = HttpSingletonService;

package/cjs/http/http-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/http/requests/batch-request.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchRequest = void 0;
+const common_1 = require("@opra/common");
+const http_request_js_1 = require("../http-request.js");
+const merge_raw_http_requests_util_js_1 = require("../utils/merge-raw-http-requests.util.js");
+class BatchRequest extends http_request_js_1.HttpRequest {
+    _handler;
+    requests;
+    options;
+    _results = new WeakMap();
+    _listeners = new Set();
+    constructor(_handler, requests, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.requests = requests;
+        this.options = options;
+        requests.forEach(request => {
+            // Overwrite the _execute method
+            Object.defineProperty(request, '_execute', {
+                writable: true,
+                enumerable: false,
+                configurable: true,
+                value: () => {
+                    return new Promise((resolve, reject) => {
+                        const x = this._results.get(request);
+                        if (x) {
+                            if (x.error)
+                                return reject(x.error);
+                            return resolve(x.response);
+                        }
+                        const callback = (error, response) => {
+                            this._listeners.delete(callback);
+                            if (error)
+                                return reject(error);
+                            resolve(response);
+                        };
+                        this._listeners.add(callback);
+                    });
+                }
+            });
+        });
+    }
+    prepare() {
+        const batch = this._buildBatchMultipart(this);
+        const headers = {
+            'content-type': 'multipart/mixed;boundary=' + batch.boundary
+        };
+        return (0, merge_raw_http_requests_util_js_1.mergeRawHttpRequests)({
+            method: 'POST',
+            path: '/$batch',
+            headers,
+            body: batch.stream()
+        }, this.options.http);
+    }
+    _buildBatchMultipart(batch) {
+        const multipart = new common_1.BatchMultipart();
+        for (const req of batch.requests) {
+            const prepared = req.prepare();
+            if (req instanceof BatchRequest) {
+                const subMultipart = this._buildBatchMultipart(req);
+                multipart.addBatch(subMultipart);
+                continue;
+            }
+            multipart.addRequestPart({
+                method: prepared.method,
+                url: prepared.path,
+                headers: prepared.headers,
+                data: prepared.body
+            });
+        }
+        return multipart;
+    }
+    async _execute() {
+        const req = this.prepare();
+        const resp = await this._handler(req);
+        return resp;
+    }
+}
+exports.BatchRequest = BatchRequest;

package/cjs/http/requests/collection-create-request.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionCreateRequest = void 0;
+const common_1 = require("@opra/common");
+const http_request_js_1 = require("../http-request.js");
+const merge_raw_http_requests_util_js_1 = require("../utils/merge-raw-http-requests.util.js");
+class CollectionCreateRequest extends http_request_js_1.HttpRequest {
+    _handler;
+    resource;
+    data;
+    options;
+    constructor(_handler, resource, data, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.resource = resource;
+        this.data = data;
+        this.options = options;
+    }
+    prepare() {
+        const searchParams = new common_1.OpraURLSearchParams();
+        if (this.options.include)
+            searchParams.set('$include', this.options.include);
+        if (this.options.pick)
+            searchParams.set('$pick', this.options.pick);
+        if (this.options.omit)
+            searchParams.set('$omit', this.options.omit);
+        return (0, merge_raw_http_requests_util_js_1.mergeRawHttpRequests)({
+            method: 'POST',
+            path: this.resource.name,
+            params: searchParams,
+            body: this.data,
+        }, this.options.http);
+    }
+}
+exports.CollectionCreateRequest = CollectionCreateRequest;

package/cjs/http/requests/collection-delete-many-request.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionDeleteManyRequest = void 0;
+const common_1 = require("@opra/common");
+const http_request_js_1 = require("../http-request.js");
+const merge_raw_http_requests_util_js_1 = require("../utils/merge-raw-http-requests.util.js");
+class CollectionDeleteManyRequest extends http_request_js_1.HttpRequest {
+    _handler;
+    resource;
+    options;
+    constructor(_handler, resource, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.resource = resource;
+        this.options = options;
+    }
+    prepare() {
+        const searchParams = new common_1.OpraURLSearchParams();
+        if (this.options.filter)
+            searchParams.set('$filter', this.options.filter);
+        return (0, merge_raw_http_requests_util_js_1.mergeRawHttpRequests)({
+            method: 'DELETE',
+            path: this.resource.name,
+            params: searchParams,
+        }, this.options.http);
+    }
+}
+exports.CollectionDeleteManyRequest = CollectionDeleteManyRequest;

package/cjs/http/requests/collection-delete-request.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionDeleteRequest = void 0;
+const common_1 = require("@opra/common");
+const http_request_js_1 = require("../http-request.js");
+const merge_raw_http_requests_util_js_1 = require("../utils/merge-raw-http-requests.util.js");
+class CollectionDeleteRequest extends http_request_js_1.HttpRequest {
+    _handler;
+    resource;
+    keyValue;
+    options;
+    constructor(_handler, resource, keyValue, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.resource = resource;
+        this.keyValue = keyValue;
+        this.options = options;
+    }
+    prepare() {
+        if (this.keyValue == null || this.keyValue === '')
+            throw new TypeError('Key value required to perform "delete" request');
+        const path = new common_1.OpraURLPath({ resource: this.resource.name, key: this.keyValue });
+        return (0, merge_raw_http_requests_util_js_1.mergeRawHttpRequests)({
+            method: 'DELETE',
+            path: path.toString(),
+        }, this.options.http);
+    }
+}
+exports.CollectionDeleteRequest = CollectionDeleteRequest;

package/cjs/http/requests/collection-get-request.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionGetRequest = void 0;
+const common_1 = require("@opra/common");
+const http_request_js_1 = require("../http-request.js");
+const merge_raw_http_requests_util_js_1 = require("../utils/merge-raw-http-requests.util.js");
+class CollectionGetRequest extends http_request_js_1.HttpRequest {
+    _handler;
+    resource;
+    keyValue;
+    options;
+    constructor(_handler, resource, keyValue, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.resource = resource;
+        this.keyValue = keyValue;
+        this.options = options;
+    }
+    prepare() {
+        if (this.keyValue == null || this.keyValue === '')
+            throw new TypeError('Key value required to perform "get" request');
+        const path = new common_1.OpraURLPath({ resource: this.resource.name, key: this.keyValue });
+        const searchParams = new common_1.OpraURLSearchParams();
+        if (this.options.include)
+            searchParams.set('$include', this.options.include);
+        if (this.options.pick)
+            searchParams.set('$pick', this.options.pick);
+        if (this.options.omit)
+            searchParams.set('$omit', this.options.omit);
+        return (0, merge_raw_http_requests_util_js_1.mergeRawHttpRequests)({
+            method: 'GET',
+            path: path.toString(),
+            params: searchParams
+        }, this.options.http);
+    }
+}
+exports.CollectionGetRequest = CollectionGetRequest;

package/cjs/http/requests/collection-search-request.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionSearchRequest = void 0;
+const common_1 = require("@opra/common");
+const http_request_js_1 = require("../http-request.js");
+const merge_raw_http_requests_util_js_1 = require("../utils/merge-raw-http-requests.util.js");
+class CollectionSearchRequest extends http_request_js_1.HttpRequest {
+    _handler;
+    resource;
+    options;
+    constructor(_handler, resource, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.resource = resource;
+        this.options = options;
+    }
+    prepare() {
+        const searchParams = new common_1.OpraURLSearchParams();
+        if (this.options.include)
+            searchParams.set('$include', this.options.include);
+        if (this.options.pick)
+            searchParams.set('$pick', this.options.pick);
+        if (this.options.omit)
+            searchParams.set('$omit', this.options.omit);
+        if (this.options.sort)
+            searchParams.set('$sort', this.options.sort);
+        if (this.options.filter)
+            searchParams.set('$filter', this.options.filter);
+        if (this.options.limit != null)
+            searchParams.set('$limit', this.options.limit);
+        if (this.options.skip != null)
+            searchParams.set('$skip', this.options.skip);
+        if (this.options.count != null)
+            searchParams.set('$count', this.options.count);
+        if (this.options.distinct != null)
+            searchParams.set('$distinct', this.options.distinct);
+        return (0, merge_raw_http_requests_util_js_1.mergeRawHttpRequests)({
+            method: 'GET',
+            path: this.resource.name,
+            params: searchParams
+        }, this.options.http);
+    }
+}
+exports.CollectionSearchRequest = CollectionSearchRequest;

package/cjs/http/requests/collection-update-many-request.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionUpdateManyRequest = void 0;
+const common_1 = require("@opra/common");
+const http_request_js_1 = require("../http-request.js");
+const merge_raw_http_requests_util_js_1 = require("../utils/merge-raw-http-requests.util.js");
+class CollectionUpdateManyRequest extends http_request_js_1.HttpRequest {
+    _handler;
+    resource;
+    data;
+    options;
+    constructor(_handler, resource, data, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.resource = resource;
+        this.data = data;
+        this.options = options;
+    }
+    prepare() {
+        const searchParams = new common_1.OpraURLSearchParams();
+        if (this.options.filter)
+            searchParams.set('$filter', this.options.filter);
+        return (0, merge_raw_http_requests_util_js_1.mergeRawHttpRequests)({
+            method: 'PATCH',
+            path: this.resource.name,
+            params: searchParams,
+            body: this.data
+        }, this.options.http);
+    }
+}
+exports.CollectionUpdateManyRequest = CollectionUpdateManyRequest;

package/cjs/http/requests/collection-update-request.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionUpdateRequest = void 0;
+const common_1 = require("@opra/common");
+const http_request_js_1 = require("../http-request.js");
+const merge_raw_http_requests_util_js_1 = require("../utils/merge-raw-http-requests.util.js");
+class CollectionUpdateRequest extends http_request_js_1.HttpRequest {
+    _handler;
+    resource;
+    keyValue;
+    data;
+    options;
+    constructor(_handler, resource, keyValue, data, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.resource = resource;
+        this.keyValue = keyValue;
+        this.data = data;
+        this.options = options;
+    }
+    prepare() {
+        if (this.keyValue == null || this.keyValue === '')
+            throw new TypeError('Key value required to perform "get" request');
+        const path = new common_1.OpraURLPath({ resource: this.resource.name, key: this.keyValue });
+        const searchParams = new common_1.OpraURLSearchParams();
+        if (this.options.include)
+            searchParams.set('$include', this.options.include);
+        if (this.options.pick)
+            searchParams.set('$pick', this.options.pick);
+        if (this.options.omit)
+            searchParams.set('$omit', this.options.omit);
+        return (0, merge_raw_http_requests_util_js_1.mergeRawHttpRequests)({
+            method: 'PATCH',
+            path: path.toString(),
+            params: searchParams,
+            body: this.data
+        }, this.options.http);
+    }
+}
+exports.CollectionUpdateRequest = CollectionUpdateRequest;

package/cjs/http/requests/http-singleton-get-request.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpSingletonGetRequest = void 0;
+const http_request_js_1 = require("../http-request.js");
+const merge_raw_http_requests_util_js_1 = require("../utils/merge-raw-http-requests.util.js");
+class HttpSingletonGetRequest extends http_request_js_1.HttpRequest {
+    _handler;
+    resource;
+    options;
+    constructor(_handler, resource, options = {}) {
+        super(_handler, options);
+        this._handler = _handler;
+        this.resource = resource;
+        this.options = options;
+    }
+    prepare() {
+        const searchParams = new URLSearchParams();
+        if (this.options.include)
+            searchParams.set('$include', '' + this.options.include);
+        if (this.options.pick)
+            searchParams.set('$pick', '' + this.options.pick);
+        if (this.options.omit)
+            searchParams.set('$omit', '' + this.options.omit);
+        return (0, merge_raw_http_requests_util_js_1.mergeRawHttpRequests)({
+            method: 'GET',
+            path: this.resource.name,
+            params: searchParams
+        }, this.options.http);
+    }
+}
+exports.HttpSingletonGetRequest = HttpSingletonGetRequest;