@opra/core 0.4.0 → 0.6.0

package/esm/adapter/classes/execution-context.host.d.ts

@@ -0,0 +1,10 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { ContextType, IExecutionContext, IHttpExecutionContext } from '../../interfaces/execution-context.interface.js';
+export declare abstract class ExecutionContextHost extends AsyncEventEmitter implements IExecutionContext {
+    userContext: any;
+    protected constructor();
+    abstract getType(): ContextType;
+    abstract getPlatform(): string;
+    switchToHttp(): IHttpExecutionContext;
+    onFinish(fn: (...args: any[]) => (void | Promise<void>)): void;
+}

package/esm/adapter/classes/execution-context.host.js

@@ -0,0 +1,13 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
+export class ExecutionContextHost extends AsyncEventEmitter {
+    userContext;
+    constructor() {
+        super();
+    }
+    switchToHttp() {
+        throw new Error(`This is not an http context`);
+    }
+    onFinish(fn) {
+        this.on('finish', fn);
+    }
+}

package/esm/adapter/classes/express-request-wrapper.host.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Request } from 'express';
+import type { IncomingHttpHeaders } from 'http';
+import { Readable } from 'stream';
+import type { IHttpRequestWrapper } from '../../interfaces/execution-context.interface.js';
+export declare class ExpressRequestWrapperHost implements IHttpRequestWrapper {
+    readonly instance: Request;
+    constructor(instance: Request);
+    getInstance(): any;
+    getMethod(): string;
+    getUrl(): string;
+    getHeaderNames(): string[];
+    getHeader(name: string): string | string[] | undefined;
+    getHeaders(): IncomingHttpHeaders;
+    getBody(): any;
+    isCompleted(): boolean;
+    getStream(): Readable;
+}

package/esm/adapter/classes/express-request-wrapper.host.js

@@ -0,0 +1,33 @@
+export class ExpressRequestWrapperHost {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+    getMethod() {
+        return this.instance.method;
+    }
+    getUrl() {
+        return this.instance.url;
+    }
+    getHeaderNames() {
+        return Object.keys(this.instance.headers);
+    }
+    getHeader(name) {
+        return this.instance.get(name);
+    }
+    getHeaders() {
+        return this.instance.headers;
+    }
+    getBody() {
+        return this.instance.body;
+    }
+    isCompleted() {
+        return this.instance.complete;
+    }
+    getStream() {
+        return this.instance;
+    }
+}

package/esm/adapter/classes/express-response-wrapper.host.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Response } from 'express';
+import { OutgoingHttpHeaders } from 'http';
+import { Writable } from 'stream';
+import { IHttpResponseWrapper } from '../../interfaces/execution-context.interface.js';
+export declare class ExpressResponseWrapperHost implements IHttpResponseWrapper {
+    readonly instance: Response;
+    constructor(instance: Response);
+    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;
+    getStream(): Writable;
+    send(body: any): this;
+    end(): this;
+}

package/esm/adapter/classes/express-response-wrapper.host.js

@@ -0,0 +1,52 @@
+export class ExpressResponseWrapperHost {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+    getHeader(name) {
+        return this.instance.get(name);
+    }
+    getHeaders() {
+        return this.instance.getHeaders();
+    }
+    getHeaderNames() {
+        return this.instance.getHeaderNames();
+    }
+    hasHeader(name) {
+        return this.instance.hasHeader(name);
+    }
+    removeHeader(name) {
+        return this.instance.removeHeader(name);
+    }
+    setHeader(name, value) {
+        this.instance.setHeader(name, value);
+        return this;
+    }
+    getStatus() {
+        return this.instance.statusCode;
+    }
+    setStatus(value) {
+        // noinspection SuspiciousTypeOfGuard
+        this.instance.status(typeof value === 'number'
+            ? value
+            : parseInt(value, 10) || 500);
+        return this;
+    }
+    getStream() {
+        return this.instance;
+    }
+    send(body) {
+        if (typeof body === 'string' || Buffer.isBuffer(body))
+            this.instance.send(body);
+        else
+            this.instance.json(body);
+        return this;
+    }
+    end() {
+        this.instance.end();
+        return this;
+    }
+}

package/esm/adapter/classes/http-execution-context.host.d.ts

@@ -0,0 +1,13 @@
+import { ContextType, IHttpExecutionContext, IHttpRequestWrapper, IHttpResponseWrapper } from '../../interfaces/execution-context.interface.js';
+import { ExecutionContextHost } from './execution-context.host.js';
+export declare class HttpExecutionContextHost extends ExecutionContextHost implements IHttpExecutionContext {
+    protected readonly _platform: string;
+    protected readonly _request: IHttpRequestWrapper;
+    protected readonly _response: IHttpResponseWrapper;
+    constructor(_platform: string, _request: IHttpRequestWrapper, _response: IHttpResponseWrapper);
+    getType(): ContextType;
+    getPlatform(): string;
+    getRequest(): IHttpRequestWrapper;
+    getResponse(): IHttpResponseWrapper;
+    switchToHttp(): IHttpExecutionContext;
+}

package/esm/adapter/classes/http-execution-context.host.js

@@ -0,0 +1,27 @@
+import { ExecutionContextHost } from './execution-context.host.js';
+export class HttpExecutionContextHost extends ExecutionContextHost {
+    _platform;
+    _request;
+    _response;
+    constructor(_platform, _request, _response) {
+        super();
+        this._platform = _platform;
+        this._request = _request;
+        this._response = _response;
+    }
+    getType() {
+        return 'http';
+    }
+    getPlatform() {
+        return this._platform;
+    }
+    getRequest() {
+        return this._request;
+    }
+    getResponse() {
+        return this._response;
+    }
+    switchToHttp() {
+        return this;
+    }
+}

package/esm/adapter/classes/metadata.resource.d.ts

@@ -0,0 +1,8 @@
+import { SingletonResourceInfo } from '@opra/common';
+import { ISingletonResource } from '../../interfaces/resource.interface.js';
+import { JsonSingletonService } from '../../services/json-singleton-service.js';
+export declare class MetadataResource implements ISingletonResource<any> {
+    service: JsonSingletonService<any>;
+    init(resource: SingletonResourceInfo): void;
+    get(): any;
+}

package/esm/adapter/{metadata-resource.js → classes/metadata.resource.js}

@@ -1,6 +1,6 @@
 import { __decorate } from "tslib";
-import { OprSingletonResource } from '@opra/schema';
-import { JsonSingletonService } from '../services/json-singleton-service.js';
+import { OprSingletonResource } from '@opra/common';
+import { JsonSingletonService } from '../../services/json-singleton-service.js';
 let MetadataResource = class MetadataResource {
     service;
     init(resource) {

package/esm/adapter/express-adapter.d.ts

@@ -1,5 +1,5 @@
 import type { Application } from 'express';
-import { OpraDocument } from '@opra/schema';
+import { OpraDocument } from '@opra/common';
 import type { IHttpExecutionContext } from '../interfaces/execution-context.interface';
 import { OpraHttpAdapter } from './http-adapter.js';
 export declare namespace OpraExpressAdapter {

package/esm/adapter/express-adapter.js

@@ -1,6 +1,8 @@
 import bodyParser from 'body-parser';
-import { AsyncEventEmitter } from 'strict-typed-events';
-import { normalizePath } from '@opra/url';
+import { normalizePath } from '@opra/common';
+import { ExpressRequestWrapperHost } from './classes/express-request-wrapper.host.js';
+import { ExpressResponseWrapperHost } from './classes/express-response-wrapper.host.js';
+import { HttpExecutionContextHost } from './classes/http-execution-context.host.js';
 import { OpraHttpAdapter } from './http-adapter.js';
 export class OpraExpressAdapter extends OpraHttpAdapter {
     static async init(app, document, options) {
@@ -10,110 +12,10 @@ export class OpraExpressAdapter extends OpraHttpAdapter {
         app.use(prefix, bodyParser.json());
         app.use(prefix, (request, response, next) => {
             (async () => {
-                const executionContext = new ExpressExecutionContext(request, response);
+                const executionContext = new HttpExecutionContextHost('express', new ExpressRequestWrapperHost(request), new ExpressResponseWrapperHost(response));
                 await adapter.handler(executionContext);
             })().catch(e => next(e));
         });
         return adapter;
     }
 }
-class ExpressExecutionContext extends AsyncEventEmitter {
-    _request;
-    _response;
-    constructor(request, response) {
-        super();
-        this._request = new ExpressRequestWrapper(request);
-        this._response = new ExpressResponseWrapper(response);
-    }
-    getType() {
-        return 'http';
-    }
-    getPlatform() {
-        return 'express';
-    }
-    switchToHttp() {
-        return this;
-    }
-    getRequest() {
-        return this._request.getInstance();
-    }
-    getResponse() {
-        return this._response.getInstance();
-    }
-    getRequestWrapper() {
-        return this._request;
-    }
-    getResponseWrapper() {
-        return this._response;
-    }
-    onFinish(fn) {
-        this.on('finish', fn);
-    }
-}
-class ExpressRequestWrapper {
-    instance;
-    constructor(instance) {
-        this.instance = instance;
-    }
-    getInstance() {
-        return this.instance;
-    }
-    getMethod() {
-        return this.instance.method;
-    }
-    getUrl() {
-        return this.instance.url;
-    }
-    getHeaderNames() {
-        return Object.keys(this.instance.headers);
-    }
-    getHeader(name) {
-        return this.instance.get(name);
-    }
-    getHeaders() {
-        return this.instance.headers;
-    }
-    getBody() {
-        return this.instance.body;
-    }
-}
-class ExpressResponseWrapper {
-    instance;
-    constructor(instance) {
-        this.instance = instance;
-    }
-    getInstance() {
-        return this.instance;
-    }
-    getHeaderNames() {
-        return this.instance.getHeaderNames();
-    }
-    getHeader(name) {
-        return this.instance.get(name);
-    }
-    setHeader(name, value) {
-        this.instance.setHeader(name, value);
-        return this;
-    }
-    getStatus() {
-        return this.instance.statusCode;
-    }
-    setStatus(value) {
-        // noinspection SuspiciousTypeOfGuard
-        this.instance.status(typeof value === 'number'
-            ? value
-            : parseInt(value, 10) || 500);
-        return this;
-    }
-    send(body) {
-        if (typeof body === 'string' || Buffer.isBuffer(body))
-            this.instance.send(body);
-        else
-            this.instance.json(body);
-        return this;
-    }
-    end() {
-        this.instance.end();
-        return this;
-    }
-}

package/esm/adapter/http-adapter.d.ts

@@ -1,9 +1,13 @@
-import { OpraException } from '@opra/exception';
-import { OpraQuery } from '@opra/schema';
-import { OpraURL } from '@opra/url';
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http';
+import { Readable } from 'stream';
+import { OpraException, OpraQuery, OpraURL } from '@opra/common';
 import { IHttpExecutionContext } from '../interfaces/execution-context.interface.js';
 import { OpraAdapter } from './adapter.js';
-import { QueryContext } from './query-context.js';
+import { RequestContext } from './request-contexts/request-context.js';
+import { SingleRequestContext } from './request-contexts/single-request-context.js';
 export declare namespace OpraHttpAdapter {
     type Options = OpraAdapter.Options & {
         prefix?: string;
@@ -11,16 +15,23 @@ export declare namespace OpraHttpAdapter {
 }
 interface PreparedOutput {
     status: number;
-    headers: Record<string, string>;
-    body?: any;
+    headers: OutgoingHttpHeaders;
+    body?: string | Readable | Buffer;
 }
-export declare class OpraHttpAdapter<TExecutionContext extends IHttpExecutionContext> extends OpraAdapter<IHttpExecutionContext> {
-    protected prepareRequests(executionContext: TExecutionContext): QueryContext[];
-    prepareRequest(executionContext: IHttpExecutionContext, url: OpraURL, method: string, headers: Map<string, string>, body?: any): QueryContext;
+export declare class OpraHttpAdapter<TExecutionContext extends IHttpExecutionContext = IHttpExecutionContext> extends OpraAdapter<TExecutionContext> {
+    parse(executionContext: TExecutionContext): Promise<RequestContext>;
+    parseSingleQuery(args: {
+        executionContext: IHttpExecutionContext;
+        url: OpraURL;
+        method: string;
+        headers: IncomingHttpHeaders;
+        body?: any;
+        contentId?: string;
+    }): SingleRequestContext;
     buildQuery(url: OpraURL, method: string, body?: any): OpraQuery | undefined;
-    protected sendResponse(executionContext: TExecutionContext, queryContexts: QueryContext[]): Promise<void>;
-    protected isBatch(executionContext: TExecutionContext): boolean;
-    protected createOutput(ctx: QueryContext): PreparedOutput;
+    protected sendResponse(executionContext: TExecutionContext, requestContext: RequestContext): Promise<void>;
+    protected sendSingleResponse(executionContext: TExecutionContext, requestContext: SingleRequestContext): Promise<void>;
+    protected createOutput(ctx: SingleRequestContext): PreparedOutput;
     protected sendError(executionContext: TExecutionContext, error: OpraException): Promise<void>;
 }
 export {};