@opra/core 0.1.1 → 0.3.0

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

@@ -0,0 +1,505 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonCollectionService = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const core_1 = require("@nano-sql/core");
+const exception_1 = require("@opra/exception");
+const schema_1 = require("@opra/schema");
+const url_1 = require("@opra/url");
+const path_to_tree_js_1 = require("../utils/path-to-tree.js");
+let dbId = 1;
+const indexingTypes = ['int', 'float', 'number', 'date', 'string'];
+class JsonCollectionService {
+    resource;
+    _status = '';
+    _initError;
+    _dbName;
+    _initData;
+    defaultLimit;
+    constructor(resource, options) {
+        this.resource = resource;
+        if (this.resource.keyFields.length > 1)
+            throw new TypeError('JsonDataService currently doesn\'t support multiple primary keys');
+        this.defaultLimit = options?.defaultLimit ?? 10;
+        this._initData = options?.data;
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+    get primaryKey() {
+        return this.resource.keyFields[0];
+    }
+    get resourceName() {
+        return this.resource.name;
+    }
+    async close() {
+        await this._waitInitializing();
+        if (this._status === 'initialized') {
+            this._status = 'initializing';
+            try {
+                await (0, core_1.nSQL)().disconnect(this._dbName);
+            }
+            finally {
+                this._status = '';
+            }
+        }
+    }
+    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);
+    }
+    async get(keyValue, options) {
+        await this._init();
+        const select = this._convertSelect({
+            pick: options?.pick,
+            omit: options?.omit,
+            include: options?.include,
+        });
+        (0, core_1.nSQL)().useDatabase(this._dbName);
+        try {
+            const rows = await (0, core_1.nSQL)(this.resourceName)
+                .query('select', select)
+                .where([this.primaryKey, '=', keyValue])
+                .exec();
+            return unFlatten(rows[0]);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async count(options) {
+        await this._init();
+        (0, core_1.nSQL)().useDatabase(this._dbName);
+        const rows = await (0, core_1.nSQL)(this.resourceName)
+            .query('select', ['COUNT(*) as count'])
+            .where(options?.filter || [])
+            .exec();
+        return (rows[0]?.count) || 0;
+    }
+    async search(options) {
+        await this._init();
+        const select = this._convertSelect({
+            pick: options?.pick,
+            omit: options?.omit,
+            include: options?.include,
+        });
+        const filter = this._convertFilter(options?.filter);
+        (0, core_1.nSQL)().useDatabase(this._dbName);
+        const query = (0, core_1.nSQL)(this.resourceName)
+            .query('select', select)
+            .limit(options?.limit || 10)
+            .offset(options?.skip || 0)
+            .orderBy(options?.sort || [])
+            .where(filter || []);
+        return (await query.exec()).map(x => unFlatten(x));
+    }
+    async create(data, options) {
+        if (!data[this.primaryKey])
+            throw new exception_1.BadRequestError({
+                message: 'You must provide primary key value'
+            });
+        await this._init();
+        const keyValue = data[this.primaryKey];
+        (0, core_1.nSQL)().useDatabase(this._dbName);
+        const rows = await (0, core_1.nSQL)(this.resourceName).query('select', [this.primaryKey])
+            .where([this.primaryKey, '=', keyValue])
+            .exec();
+        if (rows.length)
+            throw new exception_1.ResourceConflictError(this.resourceName, this.primaryKey);
+        await (0, core_1.nSQL)(this.resourceName).query('upsert', data)
+            .exec();
+        return await this.get(keyValue, options);
+    }
+    async update(keyValue, data, options) {
+        await this._init();
+        (0, core_1.nSQL)().useDatabase(this._dbName);
+        await (0, core_1.nSQL)(this.resourceName)
+            .query('conform rows', (row) => {
+            const out = (0, putil_merge_1.default)({}, row, { deep: true, clone: true });
+            (0, putil_merge_1.default)(out, data, { deep: true });
+            return out;
+        })
+            .where([this.primaryKey, '=', keyValue])
+            .exec();
+        // await nSQL(this.resourceName).query("rebuild indexes").exec();
+        return this.get(keyValue, options);
+    }
+    async updateMany(data, options) {
+        await this._init();
+        const filter = this._convertFilter(options?.filter);
+        (0, core_1.nSQL)().useDatabase(this._dbName);
+        let affected = 0;
+        await (0, core_1.nSQL)(this.resourceName)
+            .query('conform rows', (row) => {
+            const out = (0, putil_merge_1.default)({}, row, { deep: true, clone: true });
+            (0, putil_merge_1.default)(out, data, { deep: true });
+            affected++;
+            return out;
+        })
+            .where(filter)
+            .exec();
+        // await nSQL(this.resourceName).query("rebuild indexes").exec();
+        return affected;
+    }
+    async delete(keyValue) {
+        await this._init();
+        (0, core_1.nSQL)().useDatabase(this._dbName);
+        const result = await (0, core_1.nSQL)(this.resourceName)
+            .query('delete')
+            .where([this.primaryKey, '=', keyValue])
+            .exec();
+        return !!result.length;
+    }
+    async deleteMany(options) {
+        await this._init();
+        const filter = this._convertFilter(options?.filter);
+        (0, core_1.nSQL)().useDatabase(this._dbName);
+        const result = await (0, core_1.nSQL)(this.resourceName)
+            .query('delete')
+            .where(filter)
+            .exec();
+        return result.length;
+    }
+    async _waitInitializing() {
+        if (this._status === 'initializing') {
+            return new Promise((resolve, reject) => {
+                const reTry = () => setTimeout(() => {
+                    if (this._status === '')
+                        return resolve(this._init());
+                    if (this._status === 'error')
+                        return reject(this._initError);
+                    if (this._status === 'initialized')
+                        return resolve();
+                    reTry();
+                }, 50).unref();
+                reTry();
+            });
+        }
+    }
+    async _init() {
+        await this._waitInitializing();
+        if (this._status === 'initialized')
+            return;
+        this._status = 'initializing';
+        this._dbName = 'JsonDataService_DB_' + (dbId++);
+        try {
+            const table = {
+                name: this.resourceName,
+                model: {},
+                indexes: {}
+            };
+            for (const [k, f] of this.resource.dataType.fields.entries()) {
+                const fieldType = this.resource.owner.getDataType(f.type || 'string');
+                const o = table.model[k + ':' + dataTypeToSQLType(fieldType, !!f.isArray)] = {};
+                if (k === this.primaryKey)
+                    o.pk = true;
+            }
+            // 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 f = this.dataType.getField(fieldName);
+                        const fieldType = this.resource.owner.getDataType(f.type || 'string');
+                        const t = dataTypeToSQLType(fieldType, !!f.isArray);
+                        if (indexingTypes.includes(t))
+                            indexes[fieldName + ':' + t] = {};
+                    });
+                }
+                if (searchMethod.filters) {
+                    searchMethod.filters.forEach(filter => {
+                        const f = this.dataType.getField(filter.field);
+                        const fieldType = this.resource.owner.getDataType(f.type || 'string');
+                        const t = dataTypeToSQLType(fieldType, !!f.isArray);
+                        if (indexingTypes.includes(t))
+                            indexes[filter.field + ':' + t] = {};
+                    });
+                }
+            }
+            await (0, core_1.nSQL)().createDatabase({
+                id: this._dbName,
+                version: 3,
+                tables: [table]
+            });
+            this._status = 'initialized';
+            if (this._initData) {
+                (0, core_1.nSQL)().useDatabase(this._dbName);
+                await (0, core_1.nSQL)(this.resourceName)
+                    .query('upsert', this._initData)
+                    .exec();
+                delete this._initData;
+            }
+        }
+        catch (e) {
+            this._initError = e;
+            this._status = 'error';
+            throw e;
+        }
+    }
+    _prepare(query) {
+        if (query.resource instanceof schema_1.EntityResource) {
+            if (query.dataType !== this.dataType)
+                throw new TypeError(`Query data type (${query.dataType.name}) ` +
+                    `differs from JsonDataService data type (${this.dataType.name})`);
+        }
+        switch (query.method) {
+            case 'count': {
+                const options = lodash_1.default.omitBy({
+                    filter: this._convertFilter(query.filter)
+                }, lodash_1.default.isNil);
+                return {
+                    method: query.method,
+                    options,
+                    args: [options]
+                };
+            }
+            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 === 'GetInstanceQuery') {
+                    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 === 'GetFieldQuery') {
+                    // todo
+                }
+                break;
+            }
+            case 'search': {
+                if (query.distinct)
+                    throw new exception_1.MethodNotAllowedError({
+                        message: '$distinct parameter is not supported by JsonDataService'
+                    });
+                const options = lodash_1.default.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include,
+                    filter: this._convertFilter(query.filter),
+                    sort: query.sort?.length ? query.sort : undefined,
+                    skip: query.skip,
+                    limit: query.limit,
+                    offset: query.skip,
+                    count: query.count,
+                }, lodash_1.default.isNil);
+                return {
+                    method: query.method,
+                    options,
+                    args: [options]
+                };
+            }
+            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 'updateMany': {
+                const options = lodash_1.default.omitBy({
+                    filter: this._convertFilter(query.filter)
+                }, lodash_1.default.isNil);
+                const { data } = query;
+                return {
+                    method: query.method,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'delete': {
+                const options = {};
+                const keyValue = query.keyValue;
+                return {
+                    method: query.method,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+            case 'deleteMany': {
+                const options = lodash_1.default.omitBy({
+                    filter: this._convertFilter(query.filter)
+                }, lodash_1.default.isNil);
+                return {
+                    method: query.method,
+                    options,
+                    args: [options]
+                };
+            }
+        }
+        throw new Error(`Unimplemented query type "${query.method}"`);
+    }
+    _convertSelect(args) {
+        const result = [];
+        const document = this.dataType.owner;
+        const processDataType = (dt, path, pick, omit, include) => {
+            let kl;
+            for (const [k, f] of dt.fields) {
+                kl = k.toLowerCase();
+                if (omit?.[kl] === true)
+                    continue;
+                if ((((!pick && !f.exclusive) || pick?.[kl])) || include?.[kl]) {
+                    const fieldType = document.getDataType(f.type);
+                    const subPath = (path ? path + '.' : '') + f.name;
+                    if (fieldType instanceof schema_1.ComplexType) {
+                        processDataType(fieldType, subPath, typeof pick?.[kl] === 'object' ? pick?.[kl] : undefined, typeof omit?.[kl] === 'object' ? omit?.[kl] : undefined, typeof include?.[kl] === 'object' ? include?.[kl] : undefined);
+                        continue;
+                    }
+                    result.push(subPath);
+                }
+            }
+        };
+        processDataType(this.dataType, '', (args.pick ? (0, path_to_tree_js_1.pathToTree)(args.pick, true) : undefined), (args.omit ? (0, path_to_tree_js_1.pathToTree)(args.omit, true) : undefined), (args.include ? (0, path_to_tree_js_1.pathToTree)(args.include, true) : undefined));
+        return result;
+    }
+    _convertFilter(str) {
+        const ast = typeof str === 'string'
+            ? (0, url_1.$parse)(str)
+            : str;
+        if (!ast || !(ast instanceof url_1.Expression))
+            return ast;
+        if (ast instanceof url_1.ComparisonExpression) {
+            const left = this._convertFilter(ast.left);
+            const right = this._convertFilter(ast.right);
+            switch (ast.op) {
+                case '=':
+                    return [left, '=', right];
+                case '!=':
+                    return [left, '!=', right];
+                case '>':
+                    return [left, '>', right];
+                case '>=':
+                    return [left, '>=', right];
+                case '<':
+                    return [left, '<', right];
+                case '<=':
+                    return [left, '<=', right];
+                case 'like':
+                    return [left, 'LIKE', right];
+                case '!like':
+                    return [left, 'NOT LIKE', right];
+                case 'in':
+                    return [left, 'IN', Array.isArray(right) ? right : [right]];
+                case '!in':
+                    return [left, 'NOT IN', Array.isArray(right) ? right : [right]];
+                default:
+                    throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
+            }
+        }
+        if (ast instanceof url_1.QualifiedIdentifier) {
+            return ast.value;
+        }
+        if (ast instanceof url_1.NumberLiteral ||
+            ast instanceof url_1.StringLiteral ||
+            ast instanceof url_1.BooleanLiteral ||
+            ast instanceof url_1.NullLiteral ||
+            ast instanceof url_1.DateLiteral ||
+            ast instanceof url_1.TimeLiteral) {
+            return ast.value;
+        }
+        if (ast instanceof url_1.ArrayExpression) {
+            return ast.items.map(item => this._convertFilter(item));
+        }
+        if (ast instanceof url_1.LogicalExpression) {
+            return ast.items.map(item => this._convertFilter(item))
+                .reduce((a, v) => {
+                if (a.length)
+                    a.push(ast.op.toUpperCase());
+                a.push(v);
+                return a;
+            }, []);
+        }
+        if (ast instanceof url_1.ArrayExpression) {
+            return ast.items.map(item => this._convertFilter(item));
+        }
+        if (ast instanceof url_1.ParenthesesExpression) {
+            return this._convertFilter(ast.expression);
+        }
+        throw new Error(`${ast.kind} is not implemented yet`);
+    }
+}
+exports.JsonCollectionService = JsonCollectionService;
+function unFlatten(input) {
+    if (!input)
+        return;
+    const target = {};
+    for (const k of Object.keys(input)) {
+        if (k.includes('.')) {
+            const keys = k.split('.');
+            let o = target;
+            for (let i = 0; i < keys.length - 1; i++) {
+                o = o[keys[i]] = o[keys[i]] || {};
+            }
+            o[keys[keys.length - 1]] = input[k];
+        }
+        else
+            target[k] = input[k];
+    }
+    return target;
+}
+function dataTypeToSQLType(dataType, isArray) {
+    let out = 'any';
+    if (dataType.kind !== 'SimpleType')
+        out = 'object';
+    else {
+        switch (dataType.name) {
+            case 'boolean':
+            case 'number':
+            case 'string':
+                out = dataType.name;
+                break;
+            case 'integer':
+                out = 'int';
+                break;
+            // case 'date': //there is bug in nano-sql.
+            // case 'date-time':
+            //   out = 'date';
+            //   break;
+            case 'time':
+                out = 'string';
+                break;
+            case 'uuid':
+                out = 'uuid';
+                break;
+        }
+    }
+    return out + (isArray ? '[]' : '');
+}

package/cjs/utils/path-to-tree.js

@@ -2,21 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pathToTree = void 0;
 const dotPattern = /^([^.]+)\.(.*)$/;
-function pathToTree(arr) {
+function pathToTree(arr, lowerCaseKeys) {
     if (!arr.length)
         return;
-    return _stringPathToObjectTree(arr, {});
+    return _pathToTree(arr, {}, lowerCaseKeys);
 }
 exports.pathToTree = pathToTree;
-function _stringPathToObjectTree(arr, target) {
-    for (const k of arr) {
+function _pathToTree(arr, target, lowerCaseKeys) {
+    for (let k of arr) {
+        if (lowerCaseKeys)
+            k = k.toLowerCase();
         const m = dotPattern.exec(k);
         if (m) {
             const key = m[1];
             if (target[key] === true)
                 continue;
             const sub = target[key] = typeof target[key] === 'object' ? target[key] : {};
-            _stringPathToObjectTree([m[2]], sub);
+            _pathToTree([m[2]], sub);
         }
         else {
             target[k] = true;

package/esm/enums/http-headers.enum.d.ts

@@ -2,8 +2,9 @@
  * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers#controls
  */
 export declare enum HttpHeaders {
-    X_Opra_Version = "X-OPRA-Version",
-    X_Opra_Schema = "X-OPRA-Schema",
+    X_Opra_Version = "X-Opra-Version",
+    X_Opra_Schema = "X-Opra-Schema",
+    X_Opra_Count = "X-Opra-Count",
     /**
      * Defines the authentication method that should be used to access a resource.
      */

package/esm/enums/http-headers.enum.js

@@ -5,8 +5,9 @@
 export var HttpHeaders;
 (function (HttpHeaders) {
     /* *** Custom Headers *** */
-    HttpHeaders["X_Opra_Version"] = "X-OPRA-Version";
-    HttpHeaders["X_Opra_Schema"] = "X-OPRA-Schema";
+    HttpHeaders["X_Opra_Version"] = "X-Opra-Version";
+    HttpHeaders["X_Opra_Schema"] = "X-Opra-Schema";
+    HttpHeaders["X_Opra_Count"] = "X-Opra-Count";
     /* *** Authentication *** */
     /**
      * Defines the authentication method that should be used to access a resource.

package/esm/implementation/adapter-utils/entity-resource-execute.util.d.ts

@@ -1,3 +1,3 @@
-import { EntityResource, OpraService } from '@opra/schema';
+import { EntityResource, OpraApi } from '@opra/schema';
 import { QueryContext } from '../query-context.js';
-export declare function entityResourceExecute(service: OpraService, resource: EntityResource, context: QueryContext): Promise<void>;
+export declare function entityResourceExecute(service: OpraApi, resource: EntityResource, context: QueryContext): Promise<void>;

package/esm/implementation/adapter-utils/entity-resource-execute.util.js

@@ -1,44 +1,43 @@
+import { ForbiddenError, ResourceNotFoundError } from '@opra/exception';
 import { translate } from '@opra/i18n';
-import { ComplexType } from '@opra/schema';
+import { ComplexType, OpraCountCollectionQuery } from '@opra/schema';
 import { HttpHeaders } from '../../enums/index.js';
-import { ForbiddenError, ResourceNotFoundError } from '../../exception/index.js';
-import { OpraQuery } from '../../interfaces/query.interface.js';
 export async function entityResourceExecute(service, resource, context) {
     const { query } = context;
-    if (OpraQuery.isSearchQuery(query)) {
+    if (query.kind === 'SearchCollectionQuery') {
         const promises = [];
         let search;
-        let count;
-        promises.push(executeFn(service, resource, context, query.queryType)
+        promises.push(executeFn(service, resource, context)
             .then(v => search = v));
-        if (query.count) {
-            promises.push(executeFn(service, resource, context, 'count')
-                .then(v => count = v));
+        if (query.count && resource.metadata.methods.count) {
+            const ctx = {
+                query: new OpraCountCollectionQuery(query.resource, { filter: query.filter }),
+                resultPath: ''
+            };
+            Object.setPrototypeOf(ctx, context);
+            promises.push(executeFn(service, resource, ctx));
         }
         await Promise.all(promises);
-        context.response.value = {
-            ...search,
-            ...count
-        };
+        context.response = search;
         return;
     }
-    context.response.value = await executeFn(service, resource, context, query.queryType);
+    context.response = await executeFn(service, resource, context);
 }
-async function executeFn(service, resource, context, queryType) {
-    const resolverInfo = resource.metadata.methods?.[queryType];
-    if (!resolverInfo.handler)
+async function executeFn(service, resource, context) {
+    const method = context.query.method;
+    const resolverInfo = resource.metadata.methods?.[method];
+    if (!(resolverInfo && resolverInfo.handler))
         throw new ForbiddenError({
-            message: translate('RESOLVER_FORBIDDEN', { queryType }),
+            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 (queryType) {
+    switch (method) {
         case 'search':
-            context.response.headers.set(HttpHeaders.X_Opra_Schema, '/$schema/types/' + resource.dataType.name);
-            return {
-                items: Array.isArray(result) ? result : (context.response.value ? [result] : [])
-            };
+            const items = Array.isArray(result) ? result : (context.response ? [result] : []);
+            context.responseHeaders.set(HttpHeaders.X_Opra_Schema, resource.dataType.name);
+            return items;
         case 'get':
         case 'update':
             if (!result) {
@@ -47,18 +46,22 @@ async function executeFn(service, resource, context, queryType) {
             }
             break;
         case 'count':
-            return { count: result || 0 };
+            context.responseHeaders.set(HttpHeaders.X_Opra_Count, result);
+            return;
         case 'delete':
         case 'deleteMany':
         case 'updateMany':
-            let affectedRecords;
+            let affected;
             if (typeof result === 'number')
-                affectedRecords = result;
+                affected = result;
             if (typeof result === 'boolean')
-                affectedRecords = result ? 1 : 0;
+                affected = result ? 1 : 0;
             if (typeof result === 'object')
-                affectedRecords = result.affectedRows || result.affectedRecords;
-            return { affectedRecords };
+                affected = result.affectedRows || result.affected;
+            return {
+                operation: context.query.method,
+                affected
+            };
     }
     if (!result)
         return;
@@ -72,9 +75,8 @@ async function executeFn(service, resource, context, queryType) {
             result = result && typeof result === 'object' && result[field];
         }
     }
-    if (queryType === 'create')
-        context.response.status = 201;
-    if (dataType)
-        context.response.headers.set(HttpHeaders.X_Opra_Schema, '/$schema/types/' + dataType.name);
+    if (method === 'create')
+        context.status = 201;
+    context.responseHeaders.set(HttpHeaders.X_Opra_Schema, resource.dataType.name);
     return result;
 }

package/esm/implementation/adapter-utils/resource-execute.util.d.ts

@@ -1,3 +1,3 @@
-import { BaseResource, OpraService } from '@opra/schema';
+import { OpraApi, OpraResource } from '@opra/schema';
 import { QueryContext } from '../query-context.js';
-export declare function resourceExecute(service: OpraService, resource: BaseResource, context: QueryContext): Promise<void>;
+export declare function resourceExecute(service: OpraApi, resource: OpraResource, context: QueryContext): Promise<void>;