@opra/client 0.4.0 → 0.5.0

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

@@ -1,46 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionSearchRequest = void 0;
-class CollectionSearchRequest {
-    _options;
-    constructor(_options = {}) {
-        this._options = _options;
-    }
-    omit(...fields) {
-        this._options.omit = fields.flat();
-        return this;
-    }
-    pick(...fields) {
-        this._options.pick = fields.flat();
-        return this;
-    }
-    include(...fields) {
-        this._options.include = fields.flat();
-        return this;
-    }
-    limit(value) {
-        this._options.limit = value;
-        return this;
-    }
-    skip(value) {
-        this._options.skip = value;
-        return this;
-    }
-    count(value = true) {
-        this._options.count = value;
-        return this;
-    }
-    distinct(value) {
-        this._options.distinct = value;
-        return this;
-    }
-    sort(...fields) {
-        this._options.sort = fields.flat();
-        return this;
-    }
-    filter(value) {
-        this._options.filter = value;
-        return this;
+const url_1 = require("@opra/url");
+const client_request_js_1 = require("../client-request.js");
+class CollectionSearchRequest extends client_request_js_1.OpraClientRequest {
+    client;
+    resource;
+    options;
+    constructor(client, send, resource, options = {}) {
+        super(client, send, options);
+        this.client = client;
+        this.resource = resource;
+        this.options = options;
+    }
+    prepare() {
+        const url = new url_1.OpraURL(this.client.serviceUrl);
+        url.path.join(this.resource.name);
+        if (this.options.include)
+            url.searchParams.set('$include', this.options.include);
+        if (this.options.pick)
+            url.searchParams.set('$pick', this.options.pick);
+        if (this.options.omit)
+            url.searchParams.set('$omit', this.options.omit);
+        if (this.options.sort)
+            url.searchParams.set('$sort', this.options.sort);
+        if (this.options.filter)
+            url.searchParams.set('$filter', this.options.filter);
+        if (this.options.limit != null)
+            url.searchParams.set('$limit', this.options.limit);
+        if (this.options.skip != null)
+            url.searchParams.set('$skip', this.options.skip);
+        if (this.options.count != null)
+            url.searchParams.set('$count', this.options.count);
+        if (this.options.distinct != null)
+            url.searchParams.set('$distinct', this.options.distinct);
+        return {
+            method: 'GET',
+            url: url.address,
+            params: url.searchParams
+        };
     }
 }
 exports.CollectionSearchRequest = CollectionSearchRequest;

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

@@ -1,14 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionUpdateManyRequest = void 0;
-class CollectionUpdateManyRequest {
-    _options;
-    constructor(_options = {}) {
-        this._options = _options;
+const url_1 = require("@opra/url");
+const client_request_js_1 = require("../client-request.js");
+class CollectionUpdateManyRequest extends client_request_js_1.OpraClientRequest {
+    client;
+    resource;
+    data;
+    options;
+    constructor(client, send, resource, data, options = {}) {
+        super(client, send, options);
+        this.client = client;
+        this.resource = resource;
+        this.data = data;
+        this.options = options;
     }
-    filter(value) {
-        this._options.filter = value;
-        return this;
+    prepare() {
+        const url = new url_1.OpraURL(this.client.serviceUrl);
+        url.path.join(this.resource.name);
+        if (this.options.filter)
+            url.searchParams.set('$filter', this.options.filter);
+        return {
+            method: 'PATCH',
+            url: url.address,
+            data: this.data,
+            params: url.searchParams
+        };
     }
 }
 exports.CollectionUpdateManyRequest = CollectionUpdateManyRequest;

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

@@ -1,22 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionUpdateRequest = void 0;
-class CollectionUpdateRequest {
-    _options;
-    constructor(_options = {}) {
-        this._options = _options;
+const url_1 = require("@opra/url");
+const client_request_js_1 = require("../client-request.js");
+class CollectionUpdateRequest extends client_request_js_1.OpraClientRequest {
+    client;
+    resource;
+    keyValue;
+    data;
+    options;
+    constructor(client, send, resource, keyValue, data, options = {}) {
+        super(client, send, options);
+        this.client = client;
+        this.resource = resource;
+        this.keyValue = keyValue;
+        this.data = data;
+        this.options = options;
     }
-    omit(...fields) {
-        this._options.omit = fields.flat();
-        return this;
-    }
-    pick(...fields) {
-        this._options.pick = fields.flat();
-        return this;
-    }
-    include(...fields) {
-        this._options.include = fields.flat();
-        return this;
+    prepare() {
+        const url = new url_1.OpraURL(this.client.serviceUrl);
+        url.path.join(this.resource.name);
+        url.path.get(url.path.size - 1).key = this.keyValue;
+        if (this.options.include)
+            url.searchParams.set('$include', this.options.include);
+        if (this.options.pick)
+            url.searchParams.set('$pick', this.options.pick);
+        if (this.options.omit)
+            url.searchParams.set('$omit', this.options.omit);
+        return {
+            method: 'PATCH',
+            url: url.address,
+            data: this.data,
+            params: url.searchParams
+        };
     }
 }
 exports.CollectionUpdateRequest = CollectionUpdateRequest;

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

@@ -1,22 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SingletonGetRequest = void 0;
-class SingletonGetRequest {
-    _options;
-    constructor(_options = {}) {
-        this._options = _options;
+const url_1 = require("@opra/url");
+const client_request_js_1 = require("../client-request.js");
+class SingletonGetRequest extends client_request_js_1.OpraClientRequest {
+    client;
+    resource;
+    options;
+    constructor(client, send, resource, options = {}) {
+        super(client, send, options);
+        this.client = client;
+        this.resource = resource;
+        this.options = options;
     }
-    omit(...fields) {
-        this._options.omit = fields.flat();
-        return this;
-    }
-    pick(...fields) {
-        this._options.pick = fields.flat();
-        return this;
-    }
-    include(...fields) {
-        this._options.include = fields.flat();
-        return this;
+    prepare() {
+        const url = new url_1.OpraURL(this.client.serviceUrl);
+        url.path.join(this.resource.name);
+        if (this.options.include)
+            url.searchParams.set('$include', this.options.include);
+        if (this.options.pick)
+            url.searchParams.set('$pick', this.options.pick);
+        if (this.options.omit)
+            url.searchParams.set('$omit', this.options.omit);
+        return {
+            method: 'GET',
+            url: url.address,
+            params: url.searchParams
+        };
     }
 }
 exports.SingletonGetRequest = SingletonGetRequest;

package/cjs/services/collection-node.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionNode = 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 CollectionNode {
+    client;
+    resource;
+    _send;
+    constructor(client, resource, _send) {
+        this.client = client;
+        this.resource = resource;
+        this._send = _send;
+    }
+    create(data, options) {
+        return new collection_create_request_js_1.CollectionCreateRequest(this.client, this._send, this.resource, data, options);
+    }
+    delete(keyValue, options) {
+        return new collection_delete_request_js_1.CollectionDeleteRequest(this.client, this._send, this.resource, keyValue, options);
+    }
+    deleteMany(options) {
+        return new collection_delete_many_request_js_1.CollectionDeleteManyRequest(this.client, this._send, this.resource, options);
+    }
+    get(keyValue, options) {
+        return new collection_get_request_js_1.CollectionGetRequest(this.client, this._send, this.resource, keyValue, options);
+    }
+    search(options) {
+        return new collection_search_request_js_1.CollectionSearchRequest(this.client, this._send, this.resource, options);
+    }
+    update(keyValue, data, options) {
+        return new collection_update_request_js_1.CollectionUpdateRequest(this.client, this._send, this.resource, keyValue, data, options);
+    }
+    updateMany(data, options) {
+        return new collection_update_many_request_js_1.CollectionUpdateManyRequest(this.client, this._send, this.resource, data, options);
+    }
+}
+exports.CollectionNode = CollectionNode;

package/cjs/services/singleton-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonNode = void 0;
+const singleton_get_request_js_1 = require("../requests/singleton-get-request.js");
+class SingletonNode {
+    client;
+    resource;
+    _send;
+    constructor(client, resource, _send) {
+        this.client = client;
+        this.resource = resource;
+        this._send = _send;
+    }
+    get(options) {
+        return new singleton_get_request_js_1.SingletonGetRequest(this.client, this._send, this.resource, options);
+    }
+}
+exports.SingletonNode = SingletonNode;

package/cjs/types.js

@@ -1,11 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// export type CollectionCreateRequestOptions = CollectionCreateQueryOptions & CommonRequestOptions;
-// export type CollectionDeleteRequestOptions = CommonRequestOptions;
-// export type CollectionDeleteManyRequestOptions = CollectionDeleteManyQueryOptions & CommonRequestOptions;
-// export type CollectionGetRequestOptions = CollectionGetQueryOptions & CommonRequestOptions;
-// export type CollectionUpdateRequestOptions = CollectionUpdateQueryOptions & CommonRequestOptions;
-// export type CollectionUpdateManyRequestOptions = CollectionUpdateManyQueryOptions & CommonRequestOptions;
-// export type CollectionSearchRequestOptions = CollectionSearchQueryOptions & CommonRequestOptions;
-//
-// export type SingletonGetRequestOptions = SingletonGetQueryOptions & CommonRequestOptions;

package/esm/client-request.d.ts

@@ -0,0 +1,17 @@
+import { AxiosRequestConfig } from 'axios';
+import { Observable } from 'rxjs';
+import type { OpraClient } from './client.js';
+import { ClientResponse, CommonQueryOptions } from './types.js';
+export declare abstract class OpraClientRequest<T = any, TResponse extends ClientResponse<T> = ClientResponse<T>> extends Observable<TResponse> {
+    readonly client: OpraClient;
+    protected _send: (req: AxiosRequestConfig) => Promise<TResponse>;
+    options: CommonQueryOptions;
+    readonly id: string;
+    protected _promise?: Promise<TResponse>;
+    protected constructor(client: OpraClient, _send: (req: AxiosRequestConfig) => Promise<TResponse>, options?: CommonQueryOptions);
+    abstract prepare(): AxiosRequestConfig;
+    toPromise(): Promise<TResponse>;
+    execute(): Promise<TResponse>;
+    protected _execute(): Promise<TResponse>;
+    binding(): any;
+}

package/esm/client-request.js

@@ -0,0 +1,44 @@
+import { Observable } from 'rxjs';
+import { uid } from 'uid';
+import { HeadersMap } from '@opra/common';
+export class OpraClientRequest extends Observable {
+    client;
+    _send;
+    options;
+    id;
+    _promise;
+    constructor(client, _send, options = {}) {
+        super((subscriber) => {
+            this.execute().then(v => {
+                subscriber.next(v);
+                subscriber.complete();
+            }).catch(e => subscriber.error(e));
+        });
+        this.client = client;
+        this._send = _send;
+        this.options = options;
+        this.id = uid(10);
+        this.options = options;
+    }
+    async toPromise() {
+        return this.execute();
+    }
+    async execute() {
+        const promise = this._promise || (this._promise = this._execute());
+        return await promise;
+    }
+    async _execute() {
+        const req = this.prepare();
+        const headers = this.options.http?.headers
+            ? new HeadersMap({ ...req.headers, ...this.options.http.headers }).toObject()
+            : req.headers;
+        return this._send({
+            ...this.options.http,
+            ...req,
+            headers
+        });
+    }
+    binding() {
+        return {};
+    }
+}

package/esm/client.d.ts

@@ -1,25 +1,34 @@
-import { AxiosAdapter, AxiosInstance, AxiosRequestConfig } from 'axios';
+import { AxiosInstance, AxiosInterceptorManager, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { TaskQueue } from 'power-tasks';
+import { Type } from 'ts-gems';
 import { OpraDocument } from '@opra/schema';
-import { OpraResponse } from './response.js';
-import { CollectionService } from './services/collection-service.js';
-import { SingletonService } from './services/singleton-service.js';
-import { CommonRequestOptions } from './types.js';
+import { OpraClientRequest } from './client-request.js';
+import { CollectionNode } from './services/collection-node.js';
+import { SingletonNode } from './services/singleton-node.js';
+import { ClientAdapter, ClientResponse, HttpRequestOptions } from './types.js';
 export interface OpraClientOptions {
-    adapter?: AxiosAdapter;
-    resetCache?: boolean;
-    defaultHeaders?: Record<string, string>;
-    validateStatus?: boolean | ((status: number) => boolean);
+    adapter?: ClientAdapter;
+    defaults?: HttpRequestOptions;
+    invalidateCache?: boolean;
+    concurrency?: number;
+    maxQueue?: number;
 }
 export declare class OpraClient {
-    serviceUrl: string;
-    options: OpraClientOptions;
+    protected _axios: AxiosInstance;
     protected _metadata: OpraDocument;
-    protected constructor(serviceUrl: string, options?: OpraClientOptions);
+    protected _taskQueue: TaskQueue;
+    constructor(serviceUrl: string, options?: OpraClientOptions);
+    constructor(serviceUrl: string, metadata: OpraDocument, options?: OpraClientOptions);
+    get requestInterceptors(): AxiosInterceptorManager<AxiosRequestConfig>;
+    get responseInterceptors(): AxiosInterceptorManager<AxiosResponse>;
+    get serviceUrl(): string;
+    get initialized(): boolean;
     get metadata(): OpraDocument;
-    collection<T = any, TResponse extends OpraResponse<T> = OpraResponse<T>>(name: string, options?: CommonRequestOptions): CollectionService<T, TResponse>;
-    singleton<T = any, TResponse extends OpraResponse<T> = OpraResponse<T>>(name: string, options?: CommonRequestOptions): SingletonService<T, TResponse>;
-    protected _send(req: AxiosRequestConfig, options?: CommonRequestOptions): Promise<OpraResponse>;
-    protected _createAxiosInstance(options?: CommonRequestOptions): AxiosInstance;
-    protected _fetchMetadata(): Promise<void>;
-    static create(serviceUrl: string, options?: OpraClientOptions): Promise<OpraClient>;
+    init(): Promise<void>;
+    batch<TResponse extends ClientResponse<any> = ClientResponse<any>>(requests: OpraClientRequest[]): OpraClientRequest<any, TResponse>;
+    collection<T = any, TResponse extends ClientResponse<T> = ClientResponse<T>>(name: string): CollectionNode<T, TResponse>;
+    singleton<T = any, TResponse extends ClientResponse<T> = ClientResponse<T>>(name: string): SingletonNode<T, TResponse>;
+    protected _send<TResponse extends ClientResponse>(req: AxiosRequestConfig): Promise<TResponse>;
+    protected _assertMetadata(): void;
+    static create<T extends OpraClient>(this: Type<T>, serviceUrl: string, options?: OpraClientOptions): Promise<T>;
 }

package/esm/client.js

@@ -1,91 +1,134 @@
 import axios from 'axios';
+import { TaskQueue } from 'power-tasks';
 import { ResponsiveMap } from '@opra/common';
 import { OpraDocument } from '@opra/schema';
-import { joinPath, normalizePath } from '@opra/url';
+import { normalizePath } from '@opra/url';
 import { ClientError } from './client-error.js';
-import { CollectionService } from './services/collection-service.js';
-import { SingletonService } from './services/singleton-service.js';
+import { BatchRequest } from './requests/batch-request.js';
+import { CollectionNode } from './services/collection-node.js';
+import { SingletonNode } from './services/singleton-node.js';
+const documentCache = new Map();
+const documentCacheResolvers = new Map();
 export class OpraClient {
-    serviceUrl;
-    options;
+    _axios;
     _metadata;
-    constructor(serviceUrl, options) {
-        this.options = { ...options };
-        this.serviceUrl = normalizePath(serviceUrl);
+    _taskQueue;
+    constructor(serviceUrl, arg1, arg2) {
+        let options;
+        if (arg1 instanceof OpraDocument) {
+            this._metadata = arg1;
+            options = arg2;
+        }
+        else
+            options = arg1 || arg2;
+        this._taskQueue = new TaskQueue({
+            maxQueue: options?.maxQueue,
+            concurrency: options?.concurrency
+        });
+        this._axios = axios.create();
+        this._axios.defaults.baseURL = normalizePath(serviceUrl);
+        this._axios.defaults.adapter = options?.adapter;
+        if (options?.defaults?.headers)
+            this._axios.defaults.headers.common = options.defaults.headers;
+        this._axios.defaults.auth = options?.defaults?.auth;
+        this._axios.defaults.timeout = options?.defaults?.timeout;
+        this._axios.defaults.timeoutErrorMessage = options?.defaults?.timeoutErrorMessage;
+        this._axios.defaults.xsrfCookieName = options?.defaults?.xsrfCookieName;
+        this._axios.defaults.xsrfHeaderName = options?.defaults?.xsrfHeaderName;
+        this._axios.defaults.maxRedirects = options?.defaults?.maxRedirects;
+        this._axios.defaults.maxRate = options?.defaults?.maxRate;
+        this._axios.defaults.httpAgent = options?.defaults?.httpAgent;
+        this._axios.defaults.httpsAgent = options?.defaults?.httpsAgent;
+        this._axios.defaults.proxy = options?.defaults?.proxy;
+        this._axios.defaults.validateStatus = options?.defaults?.validateStatus;
+        const document = documentCache.get(serviceUrl.toLowerCase());
+        if (document)
+            this._metadata = document;
+    }
+    get requestInterceptors() {
+        return this._axios.interceptors.request;
+    }
+    get responseInterceptors() {
+        return this._axios.interceptors.response;
+    }
+    get serviceUrl() {
+        return this._axios.defaults.baseURL || '';
+    }
+    get initialized() {
+        return !!this._metadata;
     }
     get metadata() {
+        this._assertMetadata();
         return this._metadata;
     }
-    collection(name, options) {
+    async init() {
+        let promise = documentCacheResolvers.get(this.serviceUrl.toLowerCase());
+        if (promise) {
+            await promise;
+            return;
+        }
+        promise = this._send({
+            method: 'GET',
+            url: '/$metadata',
+        });
+        documentCacheResolvers.set(this.serviceUrl.toLowerCase(), promise);
+        try {
+            const resp = await promise;
+            this._metadata = new OpraDocument(resp.data);
+        }
+        finally {
+            documentCacheResolvers.delete(this.serviceUrl.toLowerCase());
+        }
+    }
+    batch(requests) {
+        this._assertMetadata();
+        return new BatchRequest(this, requests, req => this._send(req));
+    }
+    collection(name) {
+        this._assertMetadata();
         const resource = this.metadata.getCollectionResource(name);
-        const commonOptions = {
-            headers: this.options.defaultHeaders,
-            validateStatus: this.options.validateStatus,
-            ...options,
-        };
-        return new CollectionService(this.serviceUrl, this.metadata, (req) => this._send(req, commonOptions), resource);
+        return new CollectionNode(this, resource, req => this._send(req));
     }
-    singleton(name, options) {
+    singleton(name) {
+        this._assertMetadata();
         const resource = this.metadata.getSingletonResource(name);
-        const commonOptions = {
-            headers: this.options.defaultHeaders,
-            validateStatus: this.options.validateStatus,
-            ...options,
-        };
-        return new SingletonService(this.serviceUrl, this.metadata, (req) => this._send(req, commonOptions), resource);
+        return new SingletonNode(this, resource, req => this._send(req));
     }
-    async _send(req, options) {
-        const axiosInstance = this._createAxiosInstance(options);
-        const resp = await axiosInstance.request({ ...req, validateStatus: undefined });
-        const validateStatus = options?.validateStatus;
-        if ((validateStatus === true && !(resp.status >= 200 && resp.status < 300)) ||
-            (typeof validateStatus === 'function' && !validateStatus(resp.status))) {
-            throw new ClientError({
-                message: resp.statusText,
-                status: resp.status,
-                issues: resp.data.errors
+    async _send(req) {
+        return this._taskQueue.enqueue(async () => {
+            const resp = await this._axios.request({
+                ...req,
+                validateStatus: () => true
             });
-        }
-        const rawHeaders = (typeof resp.headers.toJSON === 'function'
-            ? resp.headers.toJSON()
-            : { ...resp.headers });
-        const headers = new ResponsiveMap(rawHeaders);
-        return {
-            status: resp.status,
-            statusText: resp.statusText,
-            data: resp.data,
-            rawHeaders,
-            headers
-        };
-    }
-    _createAxiosInstance(options) {
-        const axiosInstance = axios.create();
-        axiosInstance.defaults.adapter = this.options.adapter;
-        axiosInstance.defaults.headers.common = { ...options?.headers, ...this.options.defaultHeaders };
-        if (options?.validateStatus != null) {
-            if (options.validateStatus === false)
-                axiosInstance.defaults.validateStatus = () => true;
-            else if (typeof options.validateStatus === 'function')
-                axiosInstance.defaults.validateStatus = options.validateStatus;
-        }
-        else if (this.options.validateStatus != null) {
-            if (this.options.validateStatus === false)
-                axiosInstance.defaults.validateStatus = () => true;
-            else if (typeof this.options.validateStatus === 'function')
-                axiosInstance.defaults.validateStatus = this.options.validateStatus;
-        }
-        return axiosInstance;
+            if ((resp.status >= 400 && resp.status < 600) &&
+                (this._axios.defaults.validateStatus && !this._axios.defaults.validateStatus(resp.status))) {
+                throw new ClientError({
+                    message: resp.status + ' ' + resp.statusText,
+                    status: resp.status,
+                    issues: resp.data.errors
+                });
+            }
+            const rawHeaders = (typeof resp.headers.toJSON === 'function'
+                ? resp.headers.toJSON()
+                : { ...resp.headers });
+            const headers = new ResponsiveMap(rawHeaders);
+            return {
+                status: resp.status,
+                statusText: resp.statusText,
+                data: resp.data,
+                rawHeaders,
+                headers
+            };
+        }).toPromise();
     }
-    async _fetchMetadata() {
-        const resp = await this._send({
-            method: 'GET',
-            url: joinPath(this.serviceUrl || '/', '$metadata'),
-        }, { validateStatus: true });
-        this._metadata = new OpraDocument(resp.data);
+    _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);
-        await client._fetchMetadata();
+        if (!client._metadata)
+            await client.init();
         return client;
     }
 }

package/esm/index.d.ts

@@ -1,5 +1,15 @@
 export * from './client.js';
-export * from './response.js';
+export * from './client-request.js';
 export * from './types.js';
-export * from './services/collection-service.js';
-export * from './services/singleton-service.js';
+export * from './client-error.js';
+export * from './services/collection-node.js';
+export * from './services/singleton-node.js';
+export * from './requests/batch-request.js';
+export * from './requests/collection-create-request.js';
+export * from './requests/collection-delete-request.js';
+export * from './requests/collection-delete-many-request.js';
+export * from './requests/collection-get-request.js';
+export * from './requests/collection-search-request.js';
+export * from './requests/collection-update-request.js';
+export * from './requests/collection-update-many-request.js';
+export * from './requests/singleton-get-request.js';