@opra/core 0.3.0 → 0.4.0

package/cjs/services/json-collection-service.js

@@ -195,7 +195,7 @@ class JsonCollectionService {
                 indexes: {}
             };
             for (const [k, f] of this.resource.dataType.fields.entries()) {
-                const fieldType = this.resource.owner.getDataType(f.type || 'string');
+                const fieldType = this.resource.document.getDataType(f.type || 'string');
                 const o = table.model[k + ':' + dataTypeToSQLType(fieldType, !!f.isArray)] = {};
                 if (k === this.primaryKey)
                     o.pk = true;
@@ -203,21 +203,21 @@ class JsonCollectionService {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const indexes = table.indexes;
             // Add indexes for sort fields
-            const searchMethod = this.resource.metadata.methods.search;
-            if (searchMethod) {
-                if (searchMethod.sortFields) {
-                    searchMethod.sortFields.forEach(fieldName => {
+            const searchResolver = this.resource.metadata.search;
+            if (searchResolver) {
+                if (searchResolver.sortFields) {
+                    searchResolver.sortFields.forEach(fieldName => {
                         const f = this.dataType.getField(fieldName);
-                        const fieldType = this.resource.owner.getDataType(f.type || 'string');
+                        const fieldType = this.resource.document.getDataType(f.type || 'string');
                         const t = dataTypeToSQLType(fieldType, !!f.isArray);
                         if (indexingTypes.includes(t))
                             indexes[fieldName + ':' + t] = {};
                     });
                 }
-                if (searchMethod.filters) {
-                    searchMethod.filters.forEach(filter => {
+                if (searchResolver.filters) {
+                    searchResolver.filters.forEach(filter => {
                         const f = this.dataType.getField(filter.field);
-                        const fieldType = this.resource.owner.getDataType(f.type || 'string');
+                        const fieldType = this.resource.document.getDataType(f.type || 'string');
                         const t = dataTypeToSQLType(fieldType, !!f.isArray);
                         if (indexingTypes.includes(t))
                             indexes[filter.field + ':' + t] = {};
@@ -245,10 +245,10 @@ class JsonCollectionService {
         }
     }
     _prepare(query) {
-        if (query.resource instanceof schema_1.EntityResource) {
+        if (query.resource instanceof schema_1.CollectionResourceInfo) {
             if (query.dataType !== this.dataType)
                 throw new TypeError(`Query data type (${query.dataType.name}) ` +
-                    `differs from JsonDataService data type (${this.dataType.name})`);
+                    `differs from JsonCollectionService data type (${this.dataType.name})`);
         }
         switch (query.method) {
             case 'count': {
@@ -276,7 +276,7 @@ class JsonCollectionService {
                 };
             }
             case 'get': {
-                if (query.kind === 'GetInstanceQuery') {
+                if (query.kind === 'CollectionGetQuery') {
                     const options = lodash_1.default.omitBy({
                         pick: query.pick,
                         omit: query.omit,
@@ -290,7 +290,7 @@ class JsonCollectionService {
                         args: [keyValue, options]
                     };
                 }
-                if (query.kind === 'GetFieldQuery') {
+                if (query.kind === 'FieldGetQuery') {
                     // todo
                 }
                 break;
@@ -369,7 +369,7 @@ class JsonCollectionService {
     }
     _convertSelect(args) {
         const result = [];
-        const document = this.dataType.owner;
+        const document = this.dataType.document;
         const processDataType = (dt, path, pick, omit, include) => {
             let kl;
             for (const [k, f] of dt.fields) {

package/cjs/services/json-singleton-service.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSingletonService = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const schema_1 = require("@opra/schema");
+class JsonSingletonService {
+    dataType;
+    _data;
+    constructor(dataType, options) {
+        this.dataType = dataType;
+        this._data = options?.data;
+    }
+    async processRequest(ctx) {
+        const prepared = this._prepare(ctx.query);
+        const fn = this[prepared.method];
+        if (!fn)
+            throw new TypeError(`Unimplemented method (${prepared.method})`);
+        // @ts-ignore
+        return fn.apply(this, prepared.args);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    get(options) {
+        return this._data;
+    }
+    _prepare(query) {
+        if (query.resource instanceof schema_1.SingletonResourceInfo) {
+            if (query.dataType !== this.dataType)
+                throw new TypeError(`Query data type (${query.dataType.name}) ` +
+                    `differs from JsonCollectionService data type (${this.dataType.name})`);
+        }
+        switch (query.method) {
+            case 'create': {
+                const options = lodash_1.default.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
+                }, lodash_1.default.isNil);
+                const { data } = query;
+                return {
+                    method: query.method,
+                    values: data,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'get': {
+                if (query.kind === 'CollectionGetQuery') {
+                    const options = lodash_1.default.omitBy({
+                        pick: query.pick,
+                        omit: query.omit,
+                        include: query.include
+                    }, lodash_1.default.isNil);
+                    const keyValue = query.keyValue;
+                    return {
+                        method: query.method,
+                        keyValue,
+                        options,
+                        args: [keyValue, options]
+                    };
+                }
+                if (query.kind === 'FieldGetQuery') {
+                    // todo
+                }
+                break;
+            }
+            case 'update': {
+                const options = lodash_1.default.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
+                }, lodash_1.default.isNil);
+                const { data } = query;
+                const keyValue = query.keyValue;
+                return {
+                    method: query.method,
+                    keyValue: query.keyValue,
+                    values: data,
+                    options,
+                    args: [keyValue, data, options]
+                };
+            }
+            case 'delete': {
+                const options = {};
+                const keyValue = query.keyValue;
+                return {
+                    method: query.method,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+        }
+        throw new Error(`Unimplemented query type "${query.method}"`);
+    }
+}
+exports.JsonSingletonService = JsonSingletonService;

package/esm/{implementation → adapter}/adapter.d.ts

@@ -1,6 +1,7 @@
+import { ResponsiveMap } from '@opra/common';
 import { OpraException } from '@opra/exception';
 import { FallbackLng, I18n, LanguageResource } from '@opra/i18n';
-import { OpraApi } from '@opra/schema';
+import { CollectionGetQuery, CollectionResourceInfo, ComplexType, DataType, FieldGetQuery, OpraDocument, ResourceInfo, SingletonGetQuery, SingletonResourceInfo } from '@opra/schema';
 import { IExecutionContext } from '../interfaces/execution-context.interface.js';
 import { QueryContext } from './query-context.js';
 export declare namespace OpraAdapter {
@@ -41,17 +42,24 @@ export declare namespace OpraAdapter {
     }
 }
 export declare abstract class OpraAdapter<TExecutionContext extends IExecutionContext> {
-    readonly service: OpraApi;
-    readonly i18n: I18n;
-    readonly userContextResolver?: OpraAdapter.UserContextResolver;
-    constructor(service: OpraApi, options?: Omit<OpraAdapter.Options, 'i18n'> & {
-        i18n: I18n;
-    });
+    readonly document: OpraDocument;
+    protected i18n: I18n;
+    protected userContextResolver?: OpraAdapter.UserContextResolver;
+    protected _internalResources: ResponsiveMap<string, ResourceInfo>;
+    constructor(document: OpraDocument);
     protected abstract prepareRequests(executionContext: TExecutionContext): QueryContext[];
     protected abstract sendResponse(executionContext: TExecutionContext, queryContexts: QueryContext[]): Promise<void>;
     protected abstract sendError(executionContext: TExecutionContext, error: OpraException): Promise<void>;
     protected abstract isBatch(executionContext: TExecutionContext): boolean;
     protected handler(executionContext: TExecutionContext): Promise<void>;
-    protected _getSchemaExecute(ctx: QueryContext): Promise<void>;
-    protected static initI18n(options?: OpraAdapter.Options): Promise<I18n>;
+    protected _resourcePrepare(resource: ResourceInfo, context: QueryContext): Promise<void>;
+    protected _resourceExecute(document: OpraDocument, resource: ResourceInfo, context: QueryContext): Promise<void>;
+    protected _init(options?: OpraAdapter.Options): Promise<void>;
+    protected _collectionResourceExecute(document: OpraDocument, resource: CollectionResourceInfo, context: QueryContext): Promise<any>;
+    protected _singletonResourceExecute(document: OpraDocument, resource: SingletonResourceInfo, context: QueryContext): Promise<any>;
+    protected _pathWalkThrough(query: CollectionGetQuery | SingletonGetQuery | FieldGetQuery, dataType: ComplexType, value: any, parentPath: string): Promise<{
+        value?: any;
+        dataType?: DataType;
+        path: string;
+    }>;
 }

package/esm/adapter/adapter.js

@@ -0,0 +1,315 @@
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { ResponsiveMap } from '@opra/common';
+import { FailedDependencyError, ForbiddenError, ResourceNotFoundError, wrapException } from '@opra/exception';
+import { I18n, translate } from '@opra/i18n';
+import { CollectionCountQuery, CollectionResourceInfo, ComplexType, SingletonResourceInfo } from '@opra/schema';
+import { HttpHeaders } from '../enums/index.js';
+import { createI18n } from '../utils/create-i18n.js';
+import { MetadataResource } from './metadata-resource.js';
+export class OpraAdapter {
+    document;
+    i18n;
+    userContextResolver;
+    // protected _metadataResource: SingletonResourceInfo;
+    _internalResources = new ResponsiveMap();
+    constructor(document) {
+        this.document = document;
+    }
+    async handler(executionContext) {
+        let queryContexts;
+        let userContext;
+        let failed = false;
+        try {
+            queryContexts = this.prepareRequests(executionContext);
+            let stop = false;
+            // Read requests can be executed simultaneously, write request should be executed one by one
+            let promises;
+            let exclusive = false;
+            for (const context of queryContexts) {
+                exclusive = exclusive || context.query.operation !== 'read';
+                // Wait previous read requests before executing update request
+                if (exclusive && promises) {
+                    await Promise.allSettled(promises);
+                    promises = undefined;
+                }
+                // If previous request in bucket had an error and executed an update
+                // we do not execute next requests
+                if (stop) {
+                    context.errors.push(new FailedDependencyError());
+                    continue;
+                }
+                try {
+                    const promise = (async () => {
+                        // if (context.query.method === 'metadata') {
+                        //   await this._getSchemaExecute(context); //todo
+                        //   return;
+                        // }
+                        const resource = context.query.resource;
+                        await this._resourcePrepare(resource, context);
+                        if (this.userContextResolver && !userContext)
+                            userContext = this.userContextResolver({
+                                executionContext,
+                                isBatch: this.isBatch(executionContext)
+                            });
+                        context.userContext = userContext;
+                        await this._resourceExecute(this.document, resource, context);
+                    })().catch(e => {
+                        context.errors.push(e);
+                    });
+                    if (exclusive)
+                        await promise;
+                    else {
+                        promises = promises || [];
+                        promises.push(promise);
+                    }
+                    // todo execute sub property queries
+                }
+                catch (e) {
+                    context.errors.unshift(e);
+                }
+                if (context.errors.length) {
+                    // noinspection SuspiciousTypeOfGuard
+                    context.errors = context.errors.map(e => wrapException(e));
+                    if (exclusive)
+                        stop = stop || !!context.errors.find(e => !(e.issue.severity === 'warning' || e.issue.severity === 'info'));
+                }
+            }
+            if (promises)
+                await Promise.allSettled(promises);
+            await this.sendResponse(executionContext, queryContexts);
+        }
+        catch (e) {
+            failed = true;
+            const error = wrapException(e);
+            await this.sendError(executionContext, error);
+        }
+        finally {
+            if (executionContext instanceof AsyncEventEmitter) {
+                await executionContext
+                    .emitAsyncSerial('finish', {
+                    userContext,
+                    failed
+                }).catch();
+            }
+        }
+    }
+    async _resourcePrepare(resource, context) {
+        const { query } = context;
+        const fn = resource.metadata['pre_' + query.method];
+        if (fn && typeof fn === 'function') {
+            await fn(context);
+        }
+    }
+    async _resourceExecute(document, resource, context) {
+        if (resource instanceof CollectionResourceInfo) {
+            const { query } = context;
+            if (query.kind === 'SearchCollectionQuery') {
+                const promises = [];
+                let search;
+                promises.push(this._collectionResourceExecute(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._collectionResourceExecute(document, resource, ctx));
+                }
+                await Promise.all(promises);
+                context.response = search;
+                return;
+            }
+            context.response = await this._collectionResourceExecute(document, resource, context);
+            return;
+        }
+        else if (resource instanceof SingletonResourceInfo) {
+            context.response = await this._singletonResourceExecute(document, resource, context);
+            return;
+        }
+        throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+    }
+    async _init(options) {
+        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 = 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._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);
+            }
+        }
+    }
+    async _collectionResourceExecute(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;
+        switch (method) {
+            case 'create': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query.data, query);
+                result = Array.isArray(result) ? result[0] : result;
+                if (result)
+                    context.status = 201;
+                context.responseHeaders.set(HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                return result;
+            }
+            case 'count': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query);
+                context.responseHeaders.set(HttpHeaders.X_Opra_Count, result);
+                return result;
+            }
+            case 'get': {
+                const query = context.query;
+                result = await resolverInfo.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.set(HttpHeaders.X_Opra_DataType, v.dataType.name);
+                return v.value;
+            }
+            case 'search': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query);
+                const items = Array.isArray(result) ? result : (context.response ? [result] : []);
+                context.responseHeaders.set(HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                return items;
+            }
+            case 'update': {
+                const query = context.query;
+                result = await resolverInfo.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.set(HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                return result;
+            }
+            case 'delete':
+            case 'deleteMany':
+            case 'updateMany': {
+                switch (method) {
+                    case 'delete': {
+                        const query = context.query;
+                        result = await resolverInfo.handler(context, query.keyValue, query);
+                        break;
+                    }
+                    case 'deleteMany': {
+                        const query = context.query;
+                        result = await resolverInfo.handler(context, query);
+                        break;
+                    }
+                    case 'updateMany': {
+                        const query = context.query;
+                        result = await resolverInfo.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 _singletonResourceExecute(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.set(HttpHeaders.X_Opra_DataType, v.dataType.name);
+                return v.value;
+            }
+        }
+        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];
+            }
+        }
+        if (method === 'create')
+            context.status = 201;
+        context.responseHeaders.set(HttpHeaders.X_Opra_DataType, resource.dataType.name);
+        return result;
+    }
+    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 };
+    }
+}

package/esm/{implementation → adapter}/express-adapter.d.ts

@@ -1,5 +1,5 @@
 import type { Application } from 'express';
-import { OpraApi } from '@opra/schema';
+import { OpraDocument } from '@opra/schema';
 import type { IHttpExecutionContext } from '../interfaces/execution-context.interface';
 import { OpraHttpAdapter } from './http-adapter.js';
 export declare namespace OpraExpressAdapter {
@@ -7,5 +7,5 @@ export declare namespace OpraExpressAdapter {
     }
 }
 export declare class OpraExpressAdapter extends OpraHttpAdapter<IHttpExecutionContext> {
-    static init(app: Application, service: OpraApi, options?: OpraExpressAdapter.Options): Promise<OpraExpressAdapter>;
+    static init(app: Application, document: OpraDocument, options?: OpraExpressAdapter.Options): Promise<OpraExpressAdapter>;
 }

package/esm/{implementation → adapter}/express-adapter.js

@@ -3,12 +3,9 @@ import { AsyncEventEmitter } from 'strict-typed-events';
 import { normalizePath } from '@opra/url';
 import { OpraHttpAdapter } from './http-adapter.js';
 export class OpraExpressAdapter extends OpraHttpAdapter {
-    static async init(app, service, options) {
-        const i18n = await this.initI18n(options);
-        const adapter = new OpraExpressAdapter(service, {
-            ...options,
-            i18n
-        });
+    static async init(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, (request, response, next) => {

package/esm/{implementation → adapter}/http-adapter.d.ts

@@ -1,5 +1,5 @@
 import { OpraException } from '@opra/exception';
-import { OpraAnyQuery, OpraGetMetadataQuery } from '@opra/schema';
+import { OpraQuery } from '@opra/schema';
 import { OpraURL } from '@opra/url';
 import { IHttpExecutionContext } from '../interfaces/execution-context.interface.js';
 import { OpraAdapter } from './adapter.js';
@@ -17,8 +17,7 @@ interface PreparedOutput {
 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;
-    buildGGetMetadataQuery(url: OpraURL): OpraGetMetadataQuery;
-    buildQuery(url: OpraURL, method: string, body?: any): OpraAnyQuery | undefined;
+    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;