@opra/core 0.14.0 → 0.15.0

package/esm/adapter/adapter.d.ts

@@ -1,38 +1,62 @@
-import { Task } from 'power-tasks';
-import { CollectionGetQuery, CollectionResourceInfo, ComplexType, DataType, FieldGetQuery, I18n, OpraDocument, OpraException, ResourceInfo, ResponsiveMap, SingletonGetQuery, SingletonResourceInfo } from '@opra/common';
-import { IExecutionContext } from '../interfaces/execution-context.interface.js';
-import { I18nOptions } from '../interfaces/i18n-options.interface.js';
-import { ILogger } from '../interfaces/logger.interface.js';
-import { RequestContext } from './request-contexts/request-context.js';
-import { SingleRequestContext } from './request-contexts/single-request-context.js';
+import { ApiDocument, FallbackLng, I18n, LanguageResource } from '@opra/common';
+import { ILogger } from './interfaces/logger.interface.js';
+import { RequestContext } from './interfaces/request-context.interface.js';
+/**
+ * @namespace OpraAdapter
+ */
 export declare namespace OpraAdapter {
-    type UserContextResolver = (executionContext: IExecutionContext) => object | Promise<object>;
     interface Options {
         i18n?: I18n | I18nOptions | (() => Promise<I18n>);
-        userContext?: UserContextResolver;
         logger?: ILogger;
     }
+    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[];
+    }
 }
-export declare abstract class OpraAdapter<TExecutionContext extends IExecutionContext> {
-    readonly document: OpraDocument;
-    protected userContextResolver?: OpraAdapter.UserContextResolver;
-    protected _internalResources: ResponsiveMap<string, ResourceInfo>;
+/**
+ * @class OpraAdapter
+ */
+export declare abstract class OpraAdapter {
+    readonly api: ApiDocument;
+    protected _internalDoc: ApiDocument;
     i18n: I18n;
     logger?: ILogger;
-    constructor(document: OpraDocument);
+    protected constructor(api: ApiDocument);
+    /**
+     * Initializes the adapter
+     * @param options
+     * @protected
+     */
+    protected init(options?: OpraAdapter.Options): Promise<void>;
+    /**
+     * Calls shutDown hook for all resources
+     */
     close(): Promise<void>;
-    protected abstract parse(executionContext: TExecutionContext): Promise<RequestContext>;
-    protected abstract sendResponse(executionContext: TExecutionContext, requestContext: RequestContext): Promise<void>;
-    protected abstract sendError(executionContext: TExecutionContext, error: OpraException): Promise<void>;
-    protected handler(executionContext: TExecutionContext): Promise<void>;
-    protected _requestContextToTask(executionContext: TExecutionContext, requestContext: RequestContext): Task;
-    protected _init(options?: OpraAdapter.Options): Promise<void>;
-    protected _executeResourceQuery(document: OpraDocument, resource: ResourceInfo, context: SingleRequestContext): Promise<void>;
-    protected _executeCollectionResource(document: OpraDocument, resource: CollectionResourceInfo, context: SingleRequestContext): Promise<any>;
-    protected _executeSingletonResource(document: OpraDocument, resource: SingletonResourceInfo, context: SingleRequestContext): Promise<any>;
-    protected _pathWalkThrough(query: CollectionGetQuery | SingletonGetQuery | FieldGetQuery, dataType: ComplexType, value: any, parentPath: string): Promise<{
-        value?: any;
-        dataType?: DataType;
-        path: string;
-    }>;
+    protected executeRequest(context: RequestContext): Promise<void>;
+    protected afterExecuteRequest(context: RequestContext): Promise<void>;
+    protected _createI18n(options?: OpraAdapter.I18nOptions): Promise<I18n>;
 }

package/esm/adapter/adapter.js

@@ -1,318 +1,111 @@
-import { Task } from 'power-tasks';
-import { AsyncEventEmitter } from 'strict-typed-events';
-import { CollectionCountQuery, CollectionResourceInfo, CollectionSearchQuery, ComplexType, FailedDependencyError, ForbiddenError, HttpHeaderCodes, I18n, InternalServerError, ResourceNotFoundError, ResponsiveMap, SingletonResourceInfo, translate, wrapException } from '@opra/common';
-import { createI18n } from '../utils/create-i18n.js';
-import { MetadataResource } from './classes/metadata.resource.js';
-import { BatchRequestContext } from './request-contexts/batch-request-context.js';
-import { SingleRequestContext } from './request-contexts/single-request-context.js';
-const noOp = () => void 0;
+import path from 'path';
+import { Collection, DocumentFactory, ForbiddenError, getStackFileName, I18n, OpraSchema, ResourceNotFoundError, Singleton, translate, } from '@opra/common';
+import { MetadataResource } from './internal/metadata.resource.js';
+/**
+ * @class OpraAdapter
+ */
 export class OpraAdapter {
-    constructor(document) {
-        this.document = document;
-        this._internalResources = new ResponsiveMap();
+    constructor(api) {
+        this.api = api;
     }
-    async close() {
-        const promises = [];
-        for (const r of this.document.resources.values()) {
-            if (r.instance) {
-                const shutDown = r.instance.shutDown;
-                if (shutDown)
-                    promises.push((async () => shutDown.call(r.instance))());
-            }
-        }
-        await Promise.allSettled(promises);
-    }
-    async handler(executionContext) {
-        let requestContext;
-        let failed = false;
-        try {
-            if (this.userContextResolver)
-                executionContext.userContext = this.userContextResolver(executionContext);
-            requestContext = await this.parse(executionContext);
-            const task = this._requestContextToTask(executionContext, requestContext);
-            await task.toPromise().catch(noOp);
-            await this.sendResponse(executionContext, requestContext);
-        }
-        catch (e) {
-            failed = true;
-            const error = wrapException(e);
-            await this.sendError(executionContext, error);
-            if (this.logger)
-                try {
-                    this.logger.error(e);
-                }
-                catch {
-                    // noop
-                }
-        }
-        finally {
-            if (executionContext instanceof AsyncEventEmitter) {
-                await executionContext
-                    .emitAsyncSerial('finish', {
-                    context: executionContext,
-                    failed
-                }).catch();
-            }
-        }
-    }
-    _requestContextToTask(executionContext, requestContext) {
-        if (requestContext instanceof BatchRequestContext) {
-            const children = requestContext.queries.map(q => this._requestContextToTask(executionContext, q));
-            return new Task(children, { bail: true });
-        }
-        else if (requestContext instanceof SingleRequestContext) {
-            const { query } = requestContext;
-            const task = new Task(async () => {
-                if (query.resource) {
-                    const { resource } = query;
-                    // call pre_xxx method
-                    const fn = resource.metadata['pre_' + query.method];
-                    if (fn && typeof fn === 'function') {
-                        await fn(requestContext);
-                    }
-                    await this._executeResourceQuery(this.document, resource, requestContext);
-                    // todo execute sub property queries
-                    return;
-                }
-                throw new InternalServerError('Not implemented yet');
-            }, {
-                id: requestContext.contentId,
-                exclusive: query.operation !== 'read'
-            });
-            task.on('finish', () => {
-                if (task.error) {
-                    if (task.failedDependencies)
-                        requestContext.errors.push(new FailedDependencyError());
-                    else
-                        requestContext.errors.push(wrapException(task.error));
-                    if (this.logger)
-                        try {
-                            this.logger.error(task.error);
-                        }
-                        catch {
-                            // noop
-                        }
-                    return;
-                }
-            });
-            return task;
-        }
-        /* istanbul ignore next */
-        throw new TypeError('Invalid request context instance');
-    }
-    async _init(options) {
+    /**
+     * Initializes the adapter
+     * @param options
+     * @protected
+     */
+    async init(options) {
         this.logger = options?.logger;
         if (options?.i18n instanceof I18n)
             this.i18n = options.i18n;
         else if (typeof options?.i18n === 'function')
             this.i18n = await options.i18n();
         else
-            this.i18n = await createI18n(options?.i18n);
+            this.i18n = await this._createI18n(options?.i18n);
         this.i18n = this.i18n || I18n.defaultInstance;
         if (!this.i18n.isInitialized)
             await this.i18n.init();
-        this.userContextResolver = options?.userContext;
-        const metadataResource = new MetadataResource();
-        const metadataResourceInfo = new SingletonResourceInfo(this.document, '$metadata', this.document.getComplexDataType('object'), {
-            kind: 'SingletonResource',
-            type: 'object',
-            instance: metadataResource,
-            get: {
-                handler: metadataResource.get.bind(metadataResource)
-            }
+        this._internalDoc = await DocumentFactory.createDocument({
+            version: OpraSchema.SpecVersion,
+            info: {
+                version: OpraSchema.SpecVersion,
+                title: 'Internal resources',
+            },
+            references: { 'api': this.api },
+            resources: [new MetadataResource(this.api)]
         });
-        this._internalResources.set(metadataResourceInfo.name, metadataResourceInfo);
-        metadataResource.init(metadataResourceInfo);
-        for (const r of this.document.resources.values()) {
-            if (r.instance) {
-                const init = r.instance.init;
-                if (init)
-                    await init.call(r.instance, r);
-            }
+        const promises = [];
+        for (const r of this.api.resources.values()) {
+            const onInit = r.onInit;
+            if (onInit)
+                promises.push((async () => onInit.call(r.controller, r))());
         }
+        await Promise.all(promises);
     }
-    async _executeResourceQuery(document, resource, context) {
-        if (resource instanceof CollectionResourceInfo) {
-            const { query } = context;
-            if (query instanceof CollectionSearchQuery) {
-                const promises = [];
-                let search;
-                promises.push(this._executeCollectionResource(document, resource, context)
-                    .then(v => search = v));
-                if (query.count && resource.metadata.count) {
-                    const ctx = {
-                        query: new CollectionCountQuery(query.resource, { filter: query.filter }),
-                        resultPath: ''
-                    };
-                    Object.setPrototypeOf(ctx, context);
-                    promises.push(this._executeCollectionResource(document, resource, ctx)
-                        .then(r => {
-                        context.responseHeaders[HttpHeaderCodes.X_Opra_Count] = r;
-                    }));
-                }
-                await Promise.all(promises);
-                context.response = search;
-                return;
-            }
-            context.response = await this._executeCollectionResource(document, resource, context);
-            return;
-        }
-        else if (resource instanceof SingletonResourceInfo) {
-            context.response = await this._executeSingletonResource(document, resource, context);
-            return;
+    /**
+     * Calls shutDown hook for all resources
+     */
+    async close() {
+        const promises = [];
+        for (const r of this.api.resources.values()) {
+            const onShutdown = r.onShutdown;
+            if (onShutdown)
+                promises.push((async () => onShutdown.call(r.controller, r))());
         }
-        throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+        await Promise.allSettled(promises);
     }
-    async _executeCollectionResource(document, resource, context) {
-        const method = context.query.method;
-        const handler = resource.getHandler(method);
-        if (!handler)
-            throw new ForbiddenError({
-                message: translate('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
-                severity: 'error',
-                code: 'RESOLVER_FORBIDDEN'
-            });
-        let result;
-        switch (method) {
-            case 'create': {
-                const query = context.query;
-                result = await handler(context, query.data, query);
-                result = Array.isArray(result) ? result[0] : result;
-                if (result)
-                    context.status = 201;
-                context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = resource.dataType.name;
-                return result;
-            }
-            case 'count': {
-                const query = context.query;
-                result = await handler(context, query);
-                return result;
-            }
-            case 'get': {
-                const query = context.query;
-                result = await handler(context, query.keyValue, query);
-                result = Array.isArray(result) ? result[0] : result;
-                if (!result)
-                    throw new ResourceNotFoundError(resource.name, query.keyValue);
-                const v = await this._pathWalkThrough(query, query.dataType, result, resource.name);
-                if (v.value === undefined)
-                    throw new ResourceNotFoundError(v.path);
-                if (v.dataType)
-                    context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = v.dataType.name;
-                return v.value;
-            }
-            case 'search': {
-                const query = context.query;
-                result = await handler(context, query);
-                const items = Array.isArray(result) ? result : (context.response ? [result] : []);
-                context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = resource.dataType.name;
-                return items;
-            }
-            case 'update': {
-                const query = context.query;
-                result = await handler(context, query.keyValue, query.data, query);
-                result = Array.isArray(result) ? result[0] : result;
-                if (!result)
-                    throw new ResourceNotFoundError(resource.name, query.keyValue);
-                context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = resource.dataType.name;
-                return result;
-            }
-            case 'delete':
-            case 'deleteMany':
-            case 'updateMany': {
-                switch (method) {
-                    case 'delete': {
-                        const query = context.query;
-                        result = await handler(context, query.keyValue, query);
-                        break;
-                    }
-                    case 'deleteMany': {
-                        const query = context.query;
-                        result = await handler(context, query);
-                        break;
-                    }
-                    case 'updateMany': {
-                        const query = context.query;
-                        result = await handler(context, query.data, query);
-                        break;
-                    }
-                }
-                let affected;
-                if (typeof result === 'number')
-                    affected = result;
-                if (typeof result === 'boolean')
-                    affected = result ? 1 : 0;
-                if (typeof result === 'object')
-                    affected = result.affectedRows || result.affected;
-                return {
-                    operation: context.query.method,
-                    affected
-                };
-            }
+    async executeRequest(context) {
+        const { request, response } = context;
+        const { resource, operation } = request;
+        if (resource instanceof Collection || resource instanceof Singleton) {
+            const endpoint = resource.operations[operation];
+            if (!endpoint?.handler)
+                throw new ForbiddenError({
+                    message: translate('RESOLVER_FORBIDDEN', { operation }, `The resource endpoint does not accept '{{operation}}' operations`),
+                    severity: 'error',
+                    code: 'RESOLVER_FORBIDDEN'
+                });
+            const value = await endpoint.handler(context);
+            if (value != null)
+                response.value = value;
+            await this.afterExecuteRequest(context);
         }
     }
-    async _executeSingletonResource(document, resource, context) {
-        const method = context.query.method;
-        const resolverInfo = resource.metadata[method];
-        if (!(resolverInfo && resolverInfo.handler))
-            throw new ForbiddenError({
-                message: translate('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
-                severity: 'error',
-                code: 'RESOLVER_FORBIDDEN'
-            });
-        let result = await resolverInfo.handler(context);
-        switch (method) {
-            case 'get': {
-                const query = context.query;
-                result = await resolverInfo.handler(context, query);
-                result = Array.isArray(result) ? result[0] : result;
-                if (!result)
-                    throw new ResourceNotFoundError(resource.name);
-                const v = await this._pathWalkThrough(query, query.dataType, result, resource.name);
-                if (v.value === undefined)
-                    throw new ResourceNotFoundError(v.path);
-                if (v.dataType)
-                    context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = v.dataType.name;
-                return v.value;
-            }
+    async afterExecuteRequest(context) {
+        const { request, response } = context;
+        const { resource, crud, many } = request;
+        if (crud === 'delete' || (crud === 'update' && many)) {
+            let affected = 0;
+            if (typeof response.value === 'number')
+                affected = response.value;
+            if (typeof response.value === 'boolean')
+                affected = response.value ? 1 : 0;
+            if (typeof response.value === 'object')
+                affected = response.value.affectedRows || response.value.affected;
+            response.value = {
+                operation: request.operation,
+                affected
+            };
         }
-        if (!result)
-            return;
-        result = Array.isArray(result) ? result[0] : result;
-        let dataType = resource.dataType;
-        if (context.resultPath) {
-            const pathArray = context.resultPath.split('.');
-            for (const field of pathArray) {
-                const prop = dataType instanceof ComplexType ? dataType.fields.get(field) : undefined;
-                dataType = prop && prop.type ? this.document.types.get(prop.type) : undefined;
-                result = result && typeof result === 'object' && result[field];
-            }
+        else if (response.value != null) {
+            if (!request.many)
+                response.value = Array.isArray(response.value) ? response.value[0] : response.value;
+            else
+                response.value = Array.isArray(response.value) ? response.value : [response.value];
         }
-        if (method === 'create')
-            context.status = 201;
-        context.responseHeaders[HttpHeaderCodes.X_Opra_DataType] = resource.dataType.name;
-        return result;
+        if ((request.operation === 'get' || request.operation === 'update') && response.value == null)
+            throw new ResourceNotFoundError(resource.name, request.args.key);
     }
-    async _pathWalkThrough(query, dataType, value, parentPath) {
-        const { child } = query;
-        if (!child)
-            return { value, dataType, path: parentPath };
-        // Make a case in sensitive lookup
-        const fieldNameLower = child.fieldName.toLowerCase();
-        const path = parentPath + (parentPath ? '.' : '') + child.fieldName;
-        for (const key of Object.keys(value)) {
-            if (key.toLowerCase() === fieldNameLower) {
-                let v = value[key];
-                if (v == null)
-                    return { path };
-                if (child.child && child.dataType instanceof ComplexType) {
-                    if (Array.isArray(v))
-                        v = v[0];
-                    return this._pathWalkThrough(child, child.dataType, v, path);
-                }
-                return { value: v, dataType: child.dataType, path };
-            }
-        }
-        return { path };
+    async _createI18n(options) {
+        const opts = {
+            ...options,
+        };
+        delete opts.resourceDirs;
+        const instance = I18n.createInstance(opts);
+        await instance.init();
+        await instance.loadResourceDir(path.resolve(getStackFileName(), '../../../i18n'));
+        if (options?.resourceDirs)
+            for (const dir of options.resourceDirs)
+                await instance.loadResourceDir(dir);
+        return instance;
     }
 }

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

@@ -0,0 +1,11 @@
+import type { Application } from 'express';
+import { ApiDocument } from '@opra/common';
+import { OpraHttpAdapter } from './http-adapter.js';
+export declare namespace OpraExpressAdapter {
+    interface Options extends OpraHttpAdapter.Options {
+    }
+}
+export declare class OpraExpressAdapter extends OpraHttpAdapter {
+    protected platform: string;
+    static create(app: Application, document: ApiDocument, options?: OpraExpressAdapter.Options): Promise<OpraExpressAdapter>;
+}

package/esm/adapter/http/express-adapter.js

@@ -0,0 +1,22 @@
+import bodyParser from 'body-parser';
+import { normalizePath } from '@opra/common';
+import { OpraHttpAdapter } from './http-adapter.js';
+const noOp = () => void 0;
+export class OpraExpressAdapter extends OpraHttpAdapter {
+    constructor() {
+        super(...arguments);
+        this.platform = 'express';
+    }
+    static async create(app, document, options) {
+        const adapter = new OpraExpressAdapter(document);
+        await adapter.init(options);
+        const prefix = '/' + normalizePath(options?.prefix, true);
+        app.use(prefix, bodyParser.json());
+        app.use(prefix, (req, res, next) => {
+            req.end = noOp;
+            req.send = noOp;
+            adapter.handler(req, res).catch(e => next(e));
+        });
+        return adapter;
+    }
+}

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

@@ -0,0 +1,37 @@
+import { HttpRequestMessage, HttpResponseMessage } from '@opra/common';
+import { OpraAdapter } from '../adapter.js';
+import { ILogger } from '../interfaces/logger.interface.js';
+import { Request } from '../interfaces/request.interface.js';
+import { RequestContext } from '../interfaces/request-context.interface.js';
+/**
+ * @namespace OpraHttpAdapter
+ */
+export declare namespace OpraHttpAdapter {
+    type Options = OpraAdapter.Options & {
+        prefix?: string;
+    };
+}
+/**
+ *
+ * @class OpraHttpAdapter
+ */
+export declare abstract class OpraHttpAdapter extends OpraAdapter {
+    protected abstract platform: string;
+    /**
+     * Main http request handler
+     * @param incoming
+     * @param outgoing
+     * @protected
+     */
+    protected handler(incoming: HttpRequestMessage, outgoing: HttpResponseMessage): Promise<void>;
+    protected errorHandler(incoming: HttpRequestMessage, outgoing: HttpResponseMessage, errors: any[]): Promise<void>;
+    protected log(logType: keyof ILogger, incoming: HttpRequestMessage, message: string, ...optionalParams: any[]): void;
+    protected afterExecuteRequest(context: RequestContext): Promise<void>;
+    /**
+     *
+     * @param incoming
+     * @protected
+     */
+    protected parseRequest(incoming: HttpRequestMessage): Promise<Request>;
+    protected sendResponse(context: RequestContext): Promise<void>;
+}