@opra/core 0.4.0 → 0.6.0

package/esm/adapter/http-adapter.js

@@ -1,23 +1,32 @@
-import { BadRequestError, InternalServerError, IssueSeverity, MethodNotAllowedError, NotFoundError, OpraException, wrapException } from '@opra/exception';
-import { CollectionCreateQuery, CollectionDeleteManyQuery, CollectionDeleteQuery, CollectionGetQuery, CollectionResourceInfo, CollectionSearchQuery, CollectionUpdateManyQuery, CollectionUpdateQuery, ComplexType, ContainerResourceInfo, FieldGetQuery, OpraSchema, SingletonGetQuery, SingletonResourceInfo, UnionType, } from '@opra/schema';
-import { OpraURL } from '@opra/url';
-import { HttpHeaders, HttpStatus } from '../enums/index.js';
-import { HeadersMap } from '../helpers/headers-map.js';
+import { BadRequestError, CollectionCreateQuery, CollectionDeleteManyQuery, CollectionDeleteQuery, CollectionGetQuery, CollectionResourceInfo, CollectionSearchQuery, CollectionUpdateManyQuery, CollectionUpdateQuery, ComplexType, ContainerResourceInfo, FieldGetQuery, HttpHeaders, HttpStatus, InternalServerError, isReadable, IssueSeverity, MethodNotAllowedError, normalizeHeaders, OpraException, OpraSchema, OpraURL, SingletonGetQuery, SingletonResourceInfo, UnionType, wrapException } from '@opra/common';
 import { OpraAdapter } from './adapter.js';
-import { QueryContext } from './query-context.js';
+import { SingleRequestContext } from './request-contexts/single-request-context.js';
 export class OpraHttpAdapter extends OpraAdapter {
-    prepareRequests(executionContext) {
-        const req = executionContext.getRequestWrapper();
-        // todo implement batch requests
-        if (this.isBatch(executionContext)) {
-            throw new Error('not implemented yet');
+    async parse(executionContext) {
+        const req = executionContext.getRequest();
+        const contentType = req.getHeader('content-type');
+        if (!contentType || contentType === 'application/json') {
+            const body = req.getBody();
+            const url = new OpraURL(req.getUrl());
+            return this.parseSingleQuery({
+                executionContext,
+                url,
+                method: req.getMethod(),
+                headers: req.getHeaders(),
+                body
+            });
+        }
+        if (typeof contentType === 'string' && contentType.startsWith('multipart/mixed')) {
+            // const m = BOUNDARY_PATTERN.exec(contentType);
+            // if (!m)
+            //   throw new BadRequestError({message: 'Content-Type header does not match required format'});
+            // const url = new OpraURL(req.getUrl());
+            // return await this.parseMultiPart(executionContext, url, req.getHeaders(), req.getStream(), m[1]);
         }
-        const url = new OpraURL(req.getUrl());
-        return [
-            this.prepareRequest(executionContext, url, req.getMethod(), new HeadersMap(req.getHeaders()), req.getBody())
-        ];
+        throw new BadRequestError({ message: 'Unsupported Content-Type' });
     }
-    prepareRequest(executionContext, url, method, headers, body) {
+    parseSingleQuery(args) {
+        const { executionContext, url, method, headers, body, contentId } = args;
         if (!url.path.size)
             throw new BadRequestError();
         if (method !== 'GET' && url.path.size > 1)
@@ -27,15 +36,94 @@ export class OpraHttpAdapter extends OpraAdapter {
             throw new MethodNotAllowedError({
                 message: `Method "${method}" is not allowed by target endpoint`
             });
-        return new QueryContext({
+        return new SingleRequestContext({
             service: this.document,
             executionContext,
+            headers,
             query,
-            headers: new HeadersMap(),
             params: url.searchParams,
+            contentId,
             continueOnError: query.operation === 'read'
         });
     }
+    // async parseMultiPart(
+    //     executionContext: TExecutionContext,
+    //     url: OpraURL,
+    //     headers: IncomingHttpHeaders,
+    //     input: Readable,
+    //     boundary: string
+    // ): Promise<BatchRequestContext> {
+    //   return await new Promise((resolve, reject) => {
+    //     let _resolved = false;
+    //     const dicer = new Dicer({boundary});
+    //     const doReject = (e) => {
+    //       if (_resolved) return;
+    //       _resolved = true;
+    //       reject(e);
+    //       taskQueue.clearQueue();
+    //       dicer.destroy();
+    //     }
+    //     const taskQueue = new TaskQueue({concurrency: 1});
+    //     taskQueue.on('error', doReject);
+    //
+    //     const queries: SingleRequestContext[] = [];
+    //     let partCounter = 0;
+    //     dicer.on('error', doReject);
+    //     dicer.on('part', part => {
+    //       const partIndex = partCounter++;
+    //       let header: any;
+    //       const chunks: Buffer[] = [];
+    //       part.on('error', doReject);
+    //       part.on('header', (_header) => header = normalizeHeaders(_header));
+    //       part.on('data', (chunk: Buffer) => chunks.push(chunk));
+    //       part.on('end', () => {
+    //         if (_resolved || !(header || chunks.length))
+    //           return;
+    //         const ct = header['content-type'];
+    //         if (ct === 'application/http') {
+    //           taskQueue.enqueue(async () => {
+    //             const data = Buffer.concat(chunks);
+    //             if (!(data && data.length))
+    //               return;
+    //             const r = HttpRequest.parse(data);
+    //             await callMiddlewares(r, [jsonBodyParser]);
+    //             const subUrl = new OpraURL(r.url);
+    //             const contentId = header && header['content-id'];
+    //             queries.push(this.parseSingleQuery({
+    //               executionContext,
+    //               url: subUrl,
+    //               method: r.method,
+    //               headers: r.headers,
+    //               body: r.body,
+    //               contentId
+    //             }));
+    //           });
+    //         } else doReject(new BadRequestError({
+    //           message: 'Unaccepted "content-type" header in multipart data',
+    //           details: {
+    //             position: `${boundary}[${partIndex}]`
+    //           }
+    //         }))
+    //       });
+    //     });
+    //     dicer.on('finish', () => {
+    //       taskQueue.enqueue(() => {
+    //         if (_resolved) return;
+    //         _resolved = true;
+    //         const batch = new BatchRequestContext({
+    //           service: this.document,
+    //           executionContext,
+    //           headers,
+    //           queries,
+    //           params: url.searchParams,
+    //           continueOnError: false
+    //         });
+    //         resolve(batch);
+    //       });
+    //     });
+    //     input.pipe(dicer);
+    //   });
+    // }
     buildQuery(url, method, body) {
         const pathLen = url.path.size;
         let p = url.path.get(0);
@@ -53,7 +141,12 @@ export class OpraHttpAdapter extends OpraAdapter {
             if (resource instanceof SingletonResourceInfo && !p.key) {
                 switch (method) {
                     case 'GET': {
-                        query = new SingletonGetQuery(resource);
+                        const searchParams = url.searchParams;
+                        query = new SingletonGetQuery(resource, {
+                            pick: searchParams.get('$pick'),
+                            omit: searchParams.get('$omit'),
+                            include: searchParams.get('$include')
+                        });
                     }
                 }
             }
@@ -154,38 +247,122 @@ export class OpraHttpAdapter extends OpraAdapter {
             throw new BadRequestError(e);
         }
     }
-    async sendResponse(executionContext, queryContexts) {
-        const outputPackets = [];
-        for (const ctx of queryContexts) {
-            const v = this.createOutput(ctx);
-            outputPackets.push(v);
-        }
-        if (this.isBatch(executionContext)) {
-            // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
-            return;
-        }
-        if (!outputPackets.length)
-            return this.sendError(executionContext, new NotFoundError());
-        const out = outputPackets[0];
-        const resp = executionContext.getResponseWrapper();
+    async sendResponse(executionContext, requestContext) {
+        // if (requestContext instanceof BatchRequestContext)
+        //   return this.sendBatchResponse(executionContext, requestContext);
+        if (requestContext instanceof SingleRequestContext)
+            return this.sendSingleResponse(executionContext, requestContext);
+        /* istanbul ignore next */
+        throw new TypeError('Invalid request context instance');
+    }
+    // protected async sendBatchResponse(executionContext: TExecutionContext, requestContext: BatchRequestContext) {
+    //   const resp = executionContext.getResponse();
+    //   resp.setStatus(HttpStatus.OK);
+    //   resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
+    //   resp.setHeader(HttpHeaders.Pragma, 'no-cache');
+    //   resp.setHeader(HttpHeaders.Expires, '-1');
+    //   if (requestContext.headers) {
+    //     for (const [k, v] of Object.entries(requestContext.headers)) {
+    //       if (v)
+    //         resp.setHeader(k, v);
+    //     }
+    //   }
+    //   const boundary = 'batch_' + uuid();
+    //   resp.setHeader(HttpHeaders.Content_Type, 'multipart/mixed;boundary=' + boundary);
+    //   resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
+    //
+    //   const bodyBuilder = new HttpMultipartData();
+    //
+    //   const chunks: any[] = [];
+    //   let msgIdx = 0;
+    //   for (const ctx of requestContext.queries) {
+    //     msgIdx++;
+    //     const out = this.createOutput(ctx);
+    //
+    //
+    //     // chunks.push('--' + boundary + CRLF);
+    //     // let s = 'Content-Type: application/http' + CRLF +
+    //     //     'Content-Transfer-Encoding: binary' + CRLF +
+    //     //     'Content-ID:' + (ctx.contentId || msgIdx) + CRLF +
+    //     //     CRLF +
+    //     //     'HTTP/1.1 ' + out.status + (HttpStatus[out.status] || 'Unknown') + CRLF;
+    //
+    //     let body = out.body;
+    //     const headers = out.headers || {};
+    //     if (body) {
+    //       const contentType = String(headers['content-type'] || '').split(/\s*;\s*/);
+    //       let charset = '';
+    //       if (Highland.isStream(body)) {
+    //         const l = parseInt(String(headers['content-length']), 10);
+    //         if (isNaN(l))
+    //           throw new TypeError('"content-length" header required for streamed responses');
+    //       } else if (typeof body === 'object') {
+    //         if (typeof body.stream === 'function') { // File and Blob
+    //           contentType[0] = body.type || 'binary';
+    //           headers['content-length'] = String(body.size);
+    //           body = body.stream();
+    //         } else if (Buffer.isBuffer(body)) {
+    //           headers['content-length'] = String(body.length);
+    //         } else {
+    //           contentType[0] = contentType[0] || 'application/json';
+    //           charset = 'utf-8';
+    //           body = Buffer.from(JSON.stringify(body), 'utf-8');
+    //           headers['content-length'] = String(body.length);
+    //         }
+    //       } else {
+    //         contentType[0] = contentType[0] || 'text/plain';
+    //         charset = 'utf-8';
+    //         body = Buffer.from(String(body), 'utf-8');
+    //         headers['content-length'] = String(body.length);
+    //       }
+    //       if (contentType[0]) {
+    //         if (charset) {
+    //           const i = contentType.findIndex(x => CHARSET_PATTERN.test(String(x)));
+    //           if (i > 0) contentType[i] = 'charset=' + charset;
+    //           else contentType.join('charset=' + charset);
+    //         }
+    //         headers['content-type'] = contentType.join(';');
+    //       }
+    //     }
+    //     for (const [k, v] of Object.entries(headers))
+    //       s += k + ': ' + (Array.isArray(v) ? v.join(';') : v) + CRLF
+    //
+    //     chunks.push(s + CRLF);
+    //
+    //     if (body) {
+    //       if (typeof body === 'string')
+    //         chunks.push(body + CRLF + CRLF);
+    //       else {
+    //         chunks.push(body);
+    //         chunks.push(CRLF + CRLF);
+    //       }
+    //     }
+    //   }
+    //
+    //   chunks.push('--' + boundary + '--' + CRLF);
+    //
+    //   resp.setHeader('content-type', 'multipart/mixed;boundary=' + boundary);
+    //   resp.send(Highland(chunks).flatten());
+    //   resp.end();
+    // }
+    async sendSingleResponse(executionContext, requestContext) {
+        const out = this.createOutput(requestContext);
+        const resp = executionContext.getResponse();
         resp.setStatus(out.status);
-        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
         resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
         resp.setHeader(HttpHeaders.Pragma, 'no-cache');
         resp.setHeader(HttpHeaders.Expires, '-1');
-        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
         if (out.headers) {
             for (const [k, v] of Object.entries(out.headers)) {
-                resp.setHeader(k, v);
+                if (v)
+                    resp.setHeader(k, v);
             }
         }
-        resp.send(JSON.stringify(out.body));
+        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
+        if (out.body)
+            resp.send(out.body);
         resp.end();
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    isBatch(executionContext) {
-        return false;
-    }
     createOutput(ctx) {
         const { query } = ctx;
         let body;
@@ -204,24 +381,29 @@ export class OpraHttpAdapter extends OpraAdapter {
                 if (status < HttpStatus.BAD_REQUEST)
                     status = HttpStatus.INTERNAL_SERVER_ERROR;
             }
-            body = {
+            body = this.i18n.deep({
                 operation: ctx.query.method,
                 errors: errors.map(e => e.issue)
-            };
+            });
+            body = JSON.stringify(body);
+            ctx.responseHeaders['content-type'] = 'application/json; charset=utf-8';
         }
         else {
-            body = ctx.response;
+            if (typeof ctx.response === 'object' && !(isReadable(ctx.response) || Buffer.isBuffer(ctx.response))) {
+                body = this.i18n.deep(ctx.response);
+                body = JSON.stringify(body);
+                ctx.responseHeaders['content-type'] = 'application/json; charset=utf-8';
+            }
             status = status || (query.operation === 'create' ? HttpStatus.CREATED : HttpStatus.OK);
         }
-        body = this.i18n.deep(body);
         return {
             status,
-            headers: ctx.responseHeaders.toObject(),
+            headers: normalizeHeaders(ctx.responseHeaders),
             body
         };
     }
     async sendError(executionContext, error) {
-        const resp = executionContext.getResponseWrapper();
+        const resp = executionContext.getResponse();
         resp.setStatus(error.status || 500);
         resp.setHeader(HttpHeaders.Content_Type, 'application/json');
         resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
@@ -236,3 +418,22 @@ export class OpraHttpAdapter extends OpraAdapter {
         resp.send(JSON.stringify(body));
     }
 }
+// async function callMiddlewares(req: HttpRequest, middlewares: NextHandleFunction[]): Promise<void> {
+//   return new Promise<void>((resolve, reject) => {
+//     let i = 0;
+//     const next = (err?: any) => {
+//       if (err)
+//         return reject(err);
+//       const fn = middlewares[i++];
+//       if (!fn)
+//         return resolve();
+//       try {
+//         fn(req as any, {} as any, next);
+//       } catch (e) {
+//         reject(e);
+//       }
+//     }
+//     next();
+//   });
+//
+// }

package/esm/adapter/request-contexts/batch-request-context.d.ts

@@ -0,0 +1,7 @@
+import { RequestContext, RequestContextArgs } from './request-context.js';
+import { SingleRequestContext } from './single-request-context.js';
+export declare type BatchContextArgs = RequestContextArgs & Pick<BatchRequestContext, 'queries'>;
+export declare class BatchRequestContext extends RequestContext {
+    readonly queries: SingleRequestContext[];
+    constructor(args: BatchContextArgs);
+}

package/esm/adapter/request-contexts/batch-request-context.js

@@ -0,0 +1,8 @@
+import { RequestContext } from './request-context.js';
+export class BatchRequestContext extends RequestContext {
+    queries;
+    constructor(args) {
+        super(args);
+        this.queries = args.queries;
+    }
+}

package/esm/adapter/request-contexts/request-context.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders } from 'http';
+import { HttpStatus, OpraDocument, OpraException, OpraURLSearchParams } from '@opra/common';
+import { ContextType, IExecutionContext, IHttpExecutionContext } from '../../interfaces/execution-context.interface.js';
+export declare type RequestContextArgs = Pick<RequestContext, 'contentId' | 'service' | 'executionContext' | 'params' | 'headers' | 'parentValue' | 'continueOnError'>;
+export declare class RequestContext {
+    readonly service: OpraDocument;
+    readonly executionContext: IExecutionContext;
+    readonly params: OpraURLSearchParams;
+    readonly headers: IncomingHttpHeaders;
+    readonly contentId?: string;
+    readonly parentValue?: any;
+    readonly resultPath: string;
+    readonly responseHeaders: IncomingHttpHeaders;
+    response?: any;
+    errors: OpraException[];
+    status?: HttpStatus;
+    continueOnError?: boolean;
+    constructor(args: RequestContextArgs);
+    get type(): ContextType;
+    switchToHttp(): IHttpExecutionContext;
+}

package/esm/adapter/{query-context.js → request-contexts/request-context.js}

@@ -1,28 +1,24 @@
-import { OpraURLSearchParams } from '@opra/url';
-import { HeadersMap } from '../helpers/headers-map.js';
-export class QueryContext {
+import { OpraURLSearchParams } from '@opra/common';
+export class RequestContext {
     service;
     executionContext;
-    query;
     params;
     headers;
+    contentId;
     parentValue;
     resultPath;
     responseHeaders;
     response;
     errors = [];
     status;
-    userContext;
     continueOnError;
     constructor(args) {
-        // Object.assign(this, args);
         this.service = args.service;
         this.executionContext = args.executionContext;
-        this.query = args.query;
-        // this.response = new QueryResponse();
         this.params = this.params || new OpraURLSearchParams();
-        this.headers = new HeadersMap(args.headers);
-        this.responseHeaders = new HeadersMap();
+        this.headers = args.headers;
+        this.contentId = args.contentId;
+        this.responseHeaders = {};
         this.resultPath = this.resultPath || '';
     }
     get type() {

package/esm/adapter/request-contexts/single-request-context.d.ts

@@ -0,0 +1,10 @@
+import { OpraQuery } from '@opra/common';
+import { RequestContext, RequestContextArgs } from './request-context.js';
+export declare type QueryRequestContextArgs = RequestContextArgs & {
+    readonly query: OpraQuery;
+};
+export declare class SingleRequestContext extends RequestContext {
+    readonly query: OpraQuery;
+    constructor(args: QueryRequestContextArgs);
+    get userContext(): any;
+}

package/esm/adapter/request-contexts/single-request-context.js

@@ -0,0 +1,11 @@
+import { RequestContext } from './request-context.js';
+export class SingleRequestContext extends RequestContext {
+    query;
+    constructor(args) {
+        super(args);
+        this.query = args.query;
+    }
+    get userContext() {
+        return this.executionContext.userContext;
+    }
+}

package/esm/index.d.ts

@@ -1,9 +1,9 @@
 import "reflect-metadata";
 export * from './types.js';
-export * from './enums/index.js';
 export * from './interfaces/execution-context.interface.js';
 export * from './interfaces/resource.interface.js';
-export * from './adapter/query-context.js';
+export * from './interfaces/i18n-options.interface.js';
+export * from './adapter/request-contexts/single-request-context.js';
 export * from './adapter/adapter.js';
 export * from './adapter/http-adapter.js';
 export * from './adapter/express-adapter.js';

package/esm/index.js

@@ -1,9 +1,9 @@
 import "reflect-metadata";
 export * from './types.js';
-export * from './enums/index.js';
 export * from './interfaces/execution-context.interface.js';
 export * from './interfaces/resource.interface.js';
-export * from './adapter/query-context.js';
+export * from './interfaces/i18n-options.interface.js';
+export * from './adapter/request-contexts/single-request-context.js';
 export * from './adapter/adapter.js';
 export * from './adapter/http-adapter.js';
 export * from './adapter/express-adapter.js';

package/esm/interfaces/execution-context.interface.d.ts

@@ -1,5 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http';
+import { Readable, Writable } from 'stream';
 export declare type ContextType = 'http' | 'ws' | 'rpc';
-export declare type PlatformType = 'express';
 export declare namespace IExecutionContext {
     type OnFinishArgs = {
         userContext: any;
@@ -7,33 +10,38 @@ export declare namespace IExecutionContext {
     };
 }
 export interface IExecutionContext {
+    userContext: any;
     getType(): ContextType;
-    getPlatform(): PlatformType;
+    getPlatform(): string;
     switchToHttp(): IHttpExecutionContext;
     onFinish(fn: (args: IExecutionContext.OnFinishArgs) => void | Promise<void>): any;
 }
 export interface IHttpExecutionContext extends IExecutionContext {
-    getRequest(): any;
-    getResponse(): any;
-    getRequestWrapper(): IHttpRequestWrapper;
-    getResponseWrapper(): IHttpResponseWrapper;
+    getRequest(): IHttpRequestWrapper;
+    getResponse(): IHttpResponseWrapper;
 }
 export interface IHttpRequestWrapper {
     getInstance(): any;
     getUrl(): string;
     getMethod(): string;
     getHeaderNames(): string[];
-    getHeader(name: string): string | undefined;
-    getHeaders(): Record<string, any>;
+    getHeader(name: string): string | string[] | undefined;
+    getHeaders(): IncomingHttpHeaders;
     getBody(): any;
+    isCompleted(): boolean;
+    getStream(): Readable;
 }
 export interface IHttpResponseWrapper {
     getInstance(): any;
+    getHeader(name: string): number | string | string[] | undefined;
+    getHeaders(): OutgoingHttpHeaders;
+    getHeaderNames(): string[];
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    setHeader(name: string, value: number | string | string[]): this;
     getStatus(): number | undefined;
     setStatus(value: number): this;
-    getHeaderNames(name: string): string[];
-    getHeader(name: string): string | undefined;
-    setHeader(name: string, value: string): this;
+    getStream(): Writable;
     send(body: any): this;
     end(): this;
 }

package/esm/interfaces/i18n-options.interface.d.ts

@@ -0,0 +1,28 @@
+import { FallbackLng, LanguageResource } from '@opra/common';
+export interface I18nOptions {
+    /**
+     * Language to use
+     * @default undefined
+     */
+    lng?: string;
+    /**
+     * Language to use if translations in user language are not available.
+     * @default 'dev'
+     */
+    fallbackLng?: false | FallbackLng;
+    /**
+     * Default namespace used if not passed to translation function
+     * @default 'translation'
+     */
+    defaultNS?: string;
+    /**
+     * Resources to initialize with
+     * @default undefined
+     */
+    resources?: LanguageResource;
+    /**
+     * Resource directories to initialize with (if not using loading or not appending using addResourceBundle)
+     * @default undefined
+     */
+    resourceDirs?: string[];
+}

package/esm/interfaces/i18n-options.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/resource.interface.d.ts

@@ -1,5 +1,5 @@
 import { Maybe } from 'ts-gems';
-import { ResourceInfo } from '@opra/schema';
+import { ResourceInfo } from '@opra/common';
 import { PartialOutput } from '../types.js';
 export interface IResource {
     init?(resource: ResourceInfo): void | Promise<void>;

package/esm/services/json-collection-service.d.ts

@@ -1,7 +1,6 @@
 import { Maybe } from 'ts-gems';
-import { CollectionResourceInfo, ComplexType, OpraQuery, OpraSchema } from '@opra/schema';
-import { Expression } from '@opra/url';
-import { QueryContext } from '../adapter/query-context.js';
+import { CollectionResourceInfo, ComplexType, Expression, OpraQuery, OpraSchema } from '@opra/common';
+import { SingleRequestContext } from '../adapter/request-contexts/single-request-context.js';
 import { PartialInput, PartialOutput } from '../types.js';
 export interface JsonCollectionServiceOptions {
     resourceName?: string;
@@ -20,7 +19,7 @@ export declare class JsonCollectionService<T, TOutput = PartialOutput<T>> {
     get primaryKey(): string;
     get resourceName(): string;
     close(): Promise<void>;
-    processRequest(ctx: QueryContext): Promise<any>;
+    processRequest(ctx: SingleRequestContext): Promise<any>;
     get(keyValue: any, options?: JsonCollectionService.GetOptions): Promise<Maybe<TOutput>>;
     count(options?: JsonCollectionService.SearchOptions): Promise<number>;
     search(options?: JsonCollectionService.SearchOptions): Promise<TOutput[]>;