@opra/client 0.4.0 → 0.5.0

package/esm/index.js

@@ -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';

package/esm/requests/batch-request.d.ts

@@ -0,0 +1,19 @@
+import { AxiosRequestConfig } from 'axios';
+import type { OpraClient } from '../client.js';
+import { OpraClientRequest } from '../client-request.js';
+import { ClientResponse, CommonQueryOptions, OpraBatchRequestOptions } from '../types.js';
+export declare const CRLF = "\r\n";
+export declare class BatchRequest<TResponse extends ClientResponse = ClientResponse>// todo
+ extends OpraClientRequest<any, TResponse> {
+    readonly client: OpraClient;
+    readonly requests: OpraClientRequest[];
+    options: OpraBatchRequestOptions & CommonQueryOptions;
+    protected _results: WeakMap<OpraClientRequest<any, ClientResponse<any>>, {
+        error?: Error | undefined;
+        response?: ClientResponse<any> | undefined;
+    }>;
+    protected _listeners: Set<(error: Error | undefined, response?: ClientResponse) => void>;
+    constructor(client: OpraClient, requests: OpraClientRequest[], send: (req: AxiosRequestConfig) => Promise<TResponse>, options?: OpraBatchRequestOptions & CommonQueryOptions);
+    prepare(): AxiosRequestConfig;
+    protected _execute(): Promise<TResponse>;
+}

package/esm/requests/batch-request.js

@@ -0,0 +1,131 @@
+import Highland from 'highland';
+import { uid } from 'uid';
+import { HeadersMap } from '@opra/common';
+import { OpraURL } from '@opra/url';
+import { OpraClientRequest } from '../client-request.js';
+export const CRLF = '\r\n';
+export class BatchRequest// todo
+ extends OpraClientRequest {
+    client;
+    requests;
+    options;
+    _results = new WeakMap();
+    _listeners = new Set();
+    constructor(client, requests, send, options = {}) {
+        super(client, send, options);
+        this.client = client;
+        this.requests = requests;
+        this.options = options;
+        requests.forEach(request => {
+            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 = (e, r) => {
+                            this._listeners.delete(callback);
+                            if (e)
+                                return reject(e);
+                            resolve(r);
+                        };
+                        this._listeners.add(callback);
+                    });
+                }
+            });
+        });
+    }
+    prepare() {
+        const { boundary, stream } = buildBatchStream(this);
+        const headers = {
+            'Content-Type': 'multipart/mixed;boundary=' + boundary
+        };
+        const url = new OpraURL(this.client.serviceUrl);
+        url.path.join('/$batch');
+        return {
+            method: 'POST',
+            url: url.address,
+            params: url.searchParams,
+            headers,
+            data: stream
+        };
+    }
+    async _execute() {
+        const req = this.prepare();
+        return this._send(req);
+    }
+}
+function buildBatchStream(batch) {
+    const chunks = [];
+    let batchIndex = 0;
+    let level = 0;
+    const processBatch = (_batch) => {
+        const boundary = `batch_${++batchIndex}_L${level}_${uid(10)}`;
+        for (const req of _batch.requests) {
+            chunks.push('--' + boundary + CRLF);
+            if (req instanceof BatchRequest) {
+                const contentHeaderIndex = chunks.push('');
+                chunks.push('Content-Transfer-Encoding: binary' + CRLF + CRLF);
+                level++;
+                const subBoundary = processBatch(req);
+                level--;
+                processBatch[contentHeaderIndex] = 'Content-Type: multipart/mixed;boundary=' + subBoundary + CRLF;
+                continue;
+            }
+            const prepared = req.prepare();
+            let s = 'Content-Type: application/http' + CRLF +
+                'Content-Transfer-Encoding: binary' + CRLF +
+                'Content-ID:' + req.id + CRLF +
+                CRLF +
+                (prepared.method || 'GET').toUpperCase() + ' ' + prepared.url + ' HTTP/1.1' + CRLF;
+            const headers = new HeadersMap(prepared.headers);
+            let data;
+            let contentType = '';
+            if (prepared.data) {
+                if (typeof prepared.data === 'string') {
+                    contentType = 'text/plain; charset=utf-8';
+                    data = prepared.data;
+                }
+                else if (Highland.isStream(prepared.data) || Buffer.isBuffer(prepared.data)) {
+                    data = prepared.data;
+                }
+                else if (typeof prepared.data.stream === 'function') {
+                    contentType = prepared.data.type || 'binary';
+                    data = prepared.data.stream(); // File and Blob
+                }
+                else if (typeof prepared.data === 'object') {
+                    contentType = 'application/json; charset=utf-8';
+                    data = JSON.stringify(prepared.data);
+                }
+                else
+                    throw new TypeError(`Invalid data type ${typeof prepared.data}`);
+            }
+            if (contentType && !headers.has('Content-Type'))
+                headers.set('Content-Type', contentType);
+            headers.forEach((v, k) => {
+                s += k + ': ' + (Array.isArray(v) ? v.join(';') : v) + CRLF;
+            });
+            if (data) {
+                if (typeof data === 'string')
+                    chunks.push(s + CRLF + data + CRLF + CRLF);
+                else {
+                    chunks.push(s + CRLF);
+                    chunks.push(data);
+                    chunks.push(CRLF + CRLF);
+                }
+            }
+            else
+                chunks.push(s + CRLF + CRLF);
+        }
+        chunks.push('--' + boundary + '--' + CRLF);
+        return boundary;
+    };
+    const boundary = processBatch(batch);
+    return { boundary, stream: Highland(chunks).flatten() };
+}

package/esm/requests/collection-create-request.d.ts

@@ -1,8 +1,13 @@
-import { CollectionCreateQueryOptions } from '@opra/schema';
-export declare class CollectionCreateRequest {
-    protected _options: CollectionCreateQueryOptions;
-    constructor(_options?: CollectionCreateQueryOptions);
-    omit(...fields: (string | string[])[]): this;
-    pick(...fields: (string | string[])[]): this;
-    include(...fields: (string | string[])[]): this;
+import { AxiosRequestConfig } from 'axios';
+import { CollectionCreateQueryOptions, CollectionResourceInfo } from '@opra/schema';
+import type { OpraClient } from '../client.js';
+import { OpraClientRequest } from '../client-request.js';
+import { ClientResponse, CommonQueryOptions, PartialInput } from '../types.js';
+export declare class CollectionCreateRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
+    readonly client: OpraClient;
+    readonly resource: CollectionResourceInfo;
+    data: PartialInput<T>;
+    options: CollectionCreateQueryOptions & CommonQueryOptions;
+    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, data: PartialInput<T>, options?: CollectionCreateQueryOptions & CommonQueryOptions);
+    prepare(): AxiosRequestConfig;
 }

package/esm/requests/collection-create-request.js

@@ -1,18 +1,31 @@
-export class CollectionCreateRequest {
-    _options;
-    constructor(_options = {}) {
-        this._options = _options;
+import { OpraURL } from '@opra/url';
+import { OpraClientRequest } from '../client-request.js';
+export class CollectionCreateRequest extends 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;
     }
-    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 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: 'POST',
+            url: url.address,
+            data: this.data,
+            params: url.searchParams
+        };
     }
 }

package/esm/requests/collection-delete-many-request.d.ts

@@ -1,7 +1,12 @@
-import { CollectionDeleteManyQueryOptions } from '@opra/schema';
-import { Expression } from '@opra/url';
-export declare class CollectionDeleteManyRequest {
-    protected _options: CollectionDeleteManyQueryOptions;
-    constructor(_options?: CollectionDeleteManyQueryOptions);
-    filter(value: string | Expression): this;
+import { AxiosRequestConfig } from 'axios';
+import { CollectionDeleteManyQueryOptions, CollectionResourceInfo } from '@opra/schema';
+import type { OpraClient } from '../client.js';
+import { OpraClientRequest } from '../client-request.js';
+import { ClientResponse, CommonQueryOptions } from '../types.js';
+export declare class CollectionDeleteManyRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
+    readonly client: OpraClient;
+    readonly resource: CollectionResourceInfo;
+    options: CollectionDeleteManyQueryOptions & CommonQueryOptions;
+    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, options?: CollectionDeleteManyQueryOptions & CommonQueryOptions);
+    prepare(): AxiosRequestConfig;
 }

package/esm/requests/collection-delete-many-request.js

@@ -1,10 +1,24 @@
-export class CollectionDeleteManyRequest {
-    _options;
-    constructor(_options = {}) {
-        this._options = _options;
+import { OpraURL } from '@opra/url';
+import { OpraClientRequest } from '../client-request.js';
+export class CollectionDeleteManyRequest extends OpraClientRequest {
+    client;
+    resource;
+    options;
+    constructor(client, send, resource, options = {}) {
+        super(client, send, options);
+        this.client = client;
+        this.resource = resource;
+        this.options = options;
     }
-    filter(value) {
-        this._options.filter = value;
-        return this;
+    prepare() {
+        const url = new OpraURL(this.client.serviceUrl);
+        url.path.join(this.resource.name);
+        if (this.options.filter)
+            url.searchParams.set('$filter', this.options.filter);
+        return {
+            method: 'DELETE',
+            url: url.address,
+            params: url.searchParams
+        };
     }
 }

package/esm/requests/collection-delete-request.d.ts

@@ -0,0 +1,13 @@
+import { AxiosRequestConfig } from 'axios';
+import { CollectionResourceInfo } from '@opra/schema';
+import type { OpraClient } from '../client.js';
+import { OpraClientRequest } from '../client-request.js';
+import { ClientResponse, CommonQueryOptions } from '../types.js';
+export declare class CollectionDeleteRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
+    readonly client: OpraClient;
+    readonly resource: CollectionResourceInfo;
+    keyValue: any;
+    options: CommonQueryOptions;
+    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, keyValue: any, options?: CommonQueryOptions);
+    prepare(): AxiosRequestConfig;
+}

package/esm/requests/collection-delete-request.js

@@ -0,0 +1,25 @@
+import { OpraURL } from '@opra/url';
+import { OpraClientRequest } from '../client-request.js';
+export class CollectionDeleteRequest extends OpraClientRequest {
+    client;
+    resource;
+    keyValue;
+    options;
+    constructor(client, send, resource, keyValue, options = {}) {
+        super(client, send, options);
+        this.client = client;
+        this.resource = resource;
+        this.keyValue = keyValue;
+        this.options = options;
+    }
+    prepare() {
+        const url = new OpraURL(this.client.serviceUrl);
+        url.path.join(this.resource.name);
+        url.path.get(url.path.size - 1).key = this.keyValue;
+        return {
+            method: 'DELETE',
+            url: url.address,
+            params: url.searchParams
+        };
+    }
+}

package/esm/requests/collection-get-request.d.ts

@@ -1,8 +1,13 @@
-import { CollectionGetQueryOptions } from '@opra/schema';
-export declare class CollectionGetRequest {
-    protected _options: CollectionGetQueryOptions;
-    constructor(_options?: CollectionGetQueryOptions);
-    omit(...fields: (string | string[])[]): this;
-    pick(...fields: (string | string[])[]): this;
-    include(...fields: (string | string[])[]): this;
+import { AxiosRequestConfig } from 'axios';
+import { CollectionGetQueryOptions, CollectionResourceInfo } from '@opra/schema';
+import type { OpraClient } from '../client.js';
+import { OpraClientRequest } from '../client-request.js';
+import { ClientResponse, CommonQueryOptions } from '../types.js';
+export declare class CollectionGetRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
+    readonly client: OpraClient;
+    readonly resource: CollectionResourceInfo;
+    keyValue: any;
+    options: CollectionGetQueryOptions & CommonQueryOptions;
+    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, keyValue: any, options?: CollectionGetQueryOptions & CommonQueryOptions);
+    prepare(): AxiosRequestConfig;
 }

package/esm/requests/collection-get-request.js

@@ -1,18 +1,31 @@
-export class CollectionGetRequest {
-    _options;
-    constructor(_options = {}) {
-        this._options = _options;
+import { OpraURL } from '@opra/url';
+import { OpraClientRequest } from '../client-request.js';
+export class CollectionGetRequest extends OpraClientRequest {
+    client;
+    resource;
+    keyValue;
+    options;
+    constructor(client, send, resource, keyValue, options = {}) {
+        super(client, send, options);
+        this.client = client;
+        this.resource = resource;
+        this.keyValue = keyValue;
+        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 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: 'GET',
+            url: url.address,
+            params: url.searchParams
+        };
     }
 }

package/esm/requests/collection-search-request.d.ts

@@ -1,15 +1,12 @@
-import { CollectionSearchQueryOptions } from '@opra/schema';
-import { Expression } from '@opra/url';
-export declare class CollectionSearchRequest {
-    protected _options: CollectionSearchQueryOptions;
-    constructor(_options?: CollectionSearchQueryOptions);
-    omit(...fields: (string | string[])[]): this;
-    pick(...fields: (string | string[])[]): this;
-    include(...fields: (string | string[])[]): this;
-    limit(value: number): this;
-    skip(value: number): this;
-    count(value?: boolean): this;
-    distinct(value: boolean): this;
-    sort(...fields: (string | string[])[]): this;
-    filter(value: string | Expression): this;
+import { AxiosRequestConfig } from 'axios';
+import { CollectionResourceInfo, CollectionSearchQueryOptions } from '@opra/schema';
+import type { OpraClient } from '../client.js';
+import { OpraClientRequest } from '../client-request.js';
+import { ClientResponse, CommonQueryOptions } from '../types.js';
+export declare class CollectionSearchRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
+    readonly client: OpraClient;
+    readonly resource: CollectionResourceInfo;
+    options: CollectionSearchQueryOptions & CommonQueryOptions;
+    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, options?: CollectionSearchQueryOptions & CommonQueryOptions);
+    prepare(): AxiosRequestConfig;
 }

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

@@ -1,42 +1,40 @@
-export 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;
+import { OpraURL } from '@opra/url';
+import { OpraClientRequest } from '../client-request.js';
+export class CollectionSearchRequest extends 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 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
+        };
     }
 }

package/esm/requests/collection-update-many-request.d.ts

@@ -1,7 +1,13 @@
-import { CollectionUpdateManyQueryOptions } from '@opra/schema';
-import { Expression } from '@opra/url';
-export declare class CollectionUpdateManyRequest {
-    protected _options: CollectionUpdateManyQueryOptions;
-    constructor(_options?: CollectionUpdateManyQueryOptions);
-    filter(value: string | Expression): this;
+import { AxiosRequestConfig } from 'axios';
+import { CollectionResourceInfo, CollectionUpdateManyQueryOptions } from '@opra/schema';
+import type { OpraClient } from '../client.js';
+import { OpraClientRequest } from '../client-request.js';
+import { ClientResponse, CommonQueryOptions, PartialInput } from '../types.js';
+export declare class CollectionUpdateManyRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
+    readonly client: OpraClient;
+    readonly resource: CollectionResourceInfo;
+    data: PartialInput<T>;
+    options: CollectionUpdateManyQueryOptions & CommonQueryOptions;
+    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, data: PartialInput<T>, options?: CollectionUpdateManyQueryOptions & CommonQueryOptions);
+    prepare(): AxiosRequestConfig;
 }

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

@@ -1,10 +1,27 @@
-export class CollectionUpdateManyRequest {
-    _options;
-    constructor(_options = {}) {
-        this._options = _options;
+import { OpraURL } from '@opra/url';
+import { OpraClientRequest } from '../client-request.js';
+export class CollectionUpdateManyRequest extends 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 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
+        };
     }
 }

package/esm/requests/collection-update-request.d.ts

@@ -1,8 +1,14 @@
-import { CollectionUpdateQueryOptions } from '@opra/schema';
-export declare class CollectionUpdateRequest {
-    protected _options: CollectionUpdateQueryOptions;
-    constructor(_options?: CollectionUpdateQueryOptions);
-    omit(...fields: (string | string[])[]): this;
-    pick(...fields: (string | string[])[]): this;
-    include(...fields: (string | string[])[]): this;
+import { AxiosRequestConfig } from 'axios';
+import { CollectionResourceInfo, CollectionUpdateQueryOptions } from '@opra/schema';
+import type { OpraClient } from '../client.js';
+import { OpraClientRequest } from '../client-request.js';
+import { ClientResponse, CommonQueryOptions, PartialInput } from '../types.js';
+export declare class CollectionUpdateRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
+    readonly client: OpraClient;
+    readonly resource: CollectionResourceInfo;
+    keyValue: any;
+    data: PartialInput<T>;
+    options: CollectionUpdateQueryOptions & CommonQueryOptions;
+    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, keyValue: any, data: PartialInput<T>, options?: CollectionUpdateQueryOptions & CommonQueryOptions);
+    prepare(): AxiosRequestConfig;
 }