@opra/core 0.1.1 → 0.2.0

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

@@ -3,153 +3,313 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonDataService = void 0;
 const tslib_1 = require("tslib");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const rule_judgment_1 = tslib_1.__importDefault(require("rule-judgment"));
+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 index_js_1 = require("../exception/index.js");
-// Fix invalid importing (with ESM) of rule-judgment package
-const createFilterFn = typeof rule_judgment_1.default === 'function'
-    ? rule_judgment_1.default
-    : rule_judgment_1.default.default;
+const path_to_tree_js_1 = require("../utils/path-to-tree.js");
+let dbId = 1;
 class JsonDataService {
-    resourceName;
-    data;
-    primaryKey;
-    constructor(args) {
-        this.resourceName = args.resourceName;
-        this.data = args.data;
-        this.primaryKey = args.primaryKey;
-    }
-    processRequest(ctx) {
-        const prepared = JsonDataService.prepare(ctx.query);
+    resource;
+    _status = '';
+    _initError;
+    _dbName;
+    _initData;
+    defaultLimit;
+    constructor(resource, options) {
+        this.resource = resource;
+        this.defaultLimit = options?.defaultLimit ?? 10;
+        this._initData = options?.data;
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+    get primaryKey() {
+        return this.resource.dataType.primaryKey;
+    }
+    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);
     }
-    get(keyValue, options) {
-        const primaryKey = this.primaryKey;
-        let v = this.data.find(x => '' + x[primaryKey] === '' + keyValue);
-        v = JsonDataService.filterFields(v, options?.pick, options?.omit, options?.include);
-        return v;
-    }
-    count(options) {
-        return this.search(options).length;
-    }
-    search(options) {
-        let out;
-        if (options?.filter) {
-            const filter = JsonDataService.convertFilter(options.filter);
-            const filterFn = createFilterFn(filter);
-            out = this.data.filter(filterFn);
-        }
-        else
-            out = this.data;
-        return out.map(v => JsonDataService.filterFields(v, options?.pick, options?.omit, options?.include));
-    }
-    create(data, options) {
-        if (this.get(data[this.primaryKey]))
-            throw new index_js_1.ResourceConflictError(this.resourceName, this.primaryKey);
-        this.data.push(data);
-        return JsonDataService.filterFields(data, options?.pick, options?.omit, options?.include);
-    }
-    update(keyValue, data, options) {
-        const primaryKey = this.primaryKey;
-        const i = this.data.findIndex(x => '' + x[primaryKey] === '' + keyValue);
-        if (i >= 0) {
-            data = Object.assign(this.data[i], data);
-            return JsonDataService.filterFields(data, options?.pick, options?.omit, options?.include);
+    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);
+        const rows = await (0, core_1.nSQL)(this.resourceName)
+            .query('select', select)
+            .where([this.primaryKey, '=', keyValue])
+            .exec();
+        return unFlatten(rows[0]);
+    }
+    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._initData).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._initData).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._initData)
+            .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 (0, core_1.nSQL)(this._initData).query("rebuild indexes").exec();
+        return this.get(keyValue, options);
+    }
+    async updateMany(data, options) {
+        await this._init();
+        const filter = this._convertFilter(options?.filter);
+        await this._init();
+        (0, core_1.nSQL)().useDatabase(this._dbName);
+        let affected = 0;
+        await (0, core_1.nSQL)(this._initData)
+            .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 (0, core_1.nSQL)(this._initData).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._initData)
+            .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._initData)
+            .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();
+            });
         }
     }
-    updateMany(data, options) {
-        const items = this.search({ filter: options?.filter });
-        for (let i = 0; i < items.length; i++) {
-            Object.assign(items[i], data);
+    async _init() {
+        await this._waitInitializing();
+        if (this._status === 'initialized')
+            return;
+        this._status = 'initializing';
+        this._dbName = 'JsonDataService_DB_' + (dbId++);
+        try {
+            const model = {
+                name: this.resourceName,
+                model: {
+                    '*:any': {}
+                },
+                indexes: {},
+                primaryKey: this.primaryKey
+            };
+            // 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');
+                        model.indexes[fieldName + ':' + dataTypeToSQLType(fieldType, !!f.isArray)] = {};
+                    });
+                }
+                if (searchMethod.filters) {
+                    searchMethod.filters.forEach(filter => {
+                        const f = this.dataType.getField(filter.field);
+                        const fieldType = this.resource.owner.getDataType(f.type || 'string');
+                        model.indexes[filter.field + ':' + dataTypeToSQLType(fieldType, !!f.isArray)] = {};
+                    });
+                }
+            }
+            await (0, core_1.nSQL)().createDatabase({
+                id: this._dbName,
+                version: 3,
+                tables: [model]
+            });
+            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;
+            }
         }
-        return items.length;
-    }
-    delete(keyValue) {
-        const primaryKey = this.primaryKey;
-        const i = this.data.findIndex(x => '' + x[primaryKey] === '' + keyValue);
-        if (i >= 0) {
-            this.data = this.data.slice(i, 1);
-            return true;
+        catch (e) {
+            this._initError = e;
+            this._status = 'error';
         }
-        return false;
-    }
-    deleteMany(options) {
-        const items = this.search({ filter: options?.filter });
-        this.data = this.data.filter(x => !items.includes(x));
-        return items.length;
-    }
-    static filterFields(obj, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    pick, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    omit, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    include) {
-        if (!obj)
-            return;
-        return obj;
     }
-    static prepare(query) {
-        switch (query.queryType) {
-            case 'create': {
+    _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({
-                    pick: query.pick?.length ? query.pick : undefined,
-                    omit: query.omit?.length ? query.omit : undefined,
-                    include: query.include?.length ? query.include : undefined,
+                    filter: this._convertFilter(query.filter)
                 }, lodash_1.default.isNil);
-                const { data } = query;
                 return {
-                    method: query.queryType,
-                    values: data,
+                    method: query.method,
                     options,
-                    args: [data, options]
+                    args: [options]
                 };
             }
-            case 'get': {
+            case 'create': {
                 const options = lodash_1.default.omitBy({
-                    pick: query.pick?.length ? query.pick : undefined,
-                    omit: query.omit?.length ? query.omit : undefined,
-                    include: query.include?.length ? query.include : undefined,
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
                 }, lodash_1.default.isNil);
-                const keyValue = query.keyValue;
+                const { data } = query;
                 return {
-                    method: query.queryType,
-                    keyValue,
+                    method: query.method,
+                    values: data,
                     options,
-                    args: [keyValue, 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?.length ? query.pick : undefined,
-                    omit: query.omit?.length ? query.omit : undefined,
-                    include: query.include?.length ? query.include : undefined,
+                    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,
-                    distinct: query.distinct,
-                    total: query.count,
-                    filter: JsonDataService.convertFilter(query.filter)
+                    count: query.count,
                 }, lodash_1.default.isNil);
                 return {
-                    method: query.queryType,
+                    method: query.method,
                     options,
                     args: [options]
                 };
             }
             case 'update': {
                 const options = lodash_1.default.omitBy({
-                    pick: query.pick?.length ? query.pick : undefined,
-                    omit: query.omit?.length ? query.omit : undefined,
-                    include: query.include?.length ? query.include : undefined,
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
                 }, lodash_1.default.isNil);
                 const { data } = query;
                 const keyValue = query.keyValue;
                 return {
-                    method: query.queryType,
+                    method: query.method,
                     keyValue: query.keyValue,
                     values: data,
                     options,
@@ -158,11 +318,11 @@ class JsonDataService {
             }
             case 'updateMany': {
                 const options = lodash_1.default.omitBy({
-                    filter: JsonDataService.convertFilter(query.filter)
+                    filter: this._convertFilter(query.filter)
                 }, lodash_1.default.isNil);
                 const { data } = query;
                 return {
-                    method: query.queryType,
+                    method: query.method,
                     options,
                     args: [data, options]
                 };
@@ -171,7 +331,7 @@ class JsonDataService {
                 const options = {};
                 const keyValue = query.keyValue;
                 return {
-                    method: query.queryType,
+                    method: query.method,
                     keyValue,
                     options,
                     args: [keyValue, options]
@@ -179,44 +339,70 @@ class JsonDataService {
             }
             case 'deleteMany': {
                 const options = lodash_1.default.omitBy({
-                    filter: JsonDataService.convertFilter(query.filter)
+                    filter: this._convertFilter(query.filter)
                 }, lodash_1.default.isNil);
                 return {
-                    method: query.queryType,
+                    method: query.method,
                     options,
                     args: [options]
                 };
             }
-            default:
-                throw new Error(`Unimplemented query type "${query.queryType}"`);
         }
+        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;
     }
-    static convertFilter(str) {
+    _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 = JsonDataService.convertFilter(ast.left);
-            const right = JsonDataService.convertFilter(ast.right);
+            const left = this._convertFilter(ast.left);
+            const right = this._convertFilter(ast.right);
             switch (ast.op) {
                 case '=':
-                    return { $eq: { [left]: right } };
+                    return [left, '=', right];
                 case '!=':
-                    return { $ne: { [left]: right } };
+                    return [left, '!=', right];
                 case '>':
-                    return { $gt: { [left]: right } };
+                    return [left, '>', right];
                 case '>=':
-                    return { $gte: { [left]: right } };
+                    return [left, '>=', right];
                 case '<':
-                    return { $lt: { [left]: right } };
+                    return [left, '<', right];
                 case '<=':
-                    return { $lte: { [left]: right } };
+                    return [left, '<=', right];
+                case 'like':
+                    return [left, 'LIKE', right];
+                case '!like':
+                    return [left, 'NOT LIKE', right];
                 case 'in':
-                    return { $in: { [left]: right } };
+                    return [left, 'IN', Array.isArray(right) ? right : [right]];
                 case '!in':
-                    return { $nin: { [left]: right } };
+                    return [left, 'NOT IN', Array.isArray(right) ? right : [right]];
                 default:
                     throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
             }
@@ -233,20 +419,70 @@ class JsonDataService {
             return ast.value;
         }
         if (ast instanceof url_1.ArrayExpression) {
-            return ast.items.map(JsonDataService.convertFilter);
+            return ast.items.map(item => this._convertFilter(item));
         }
         if (ast instanceof url_1.LogicalExpression) {
-            if (ast.op === 'or')
-                return { $or: ast.items.map(JsonDataService.convertFilter) };
-            return { $and: ast.items.map(JsonDataService.convertFilter) };
+            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(JsonDataService.convertFilter);
+            return ast.items.map(item => this._convertFilter(item));
         }
         if (ast instanceof url_1.ParenthesesExpression) {
-            return JsonDataService.convertFilter(ast.expression);
+            return this._convertFilter(ast.expression);
         }
-        throw new Error(`${ast.type} is not implemented yet`);
+        throw new Error(`${ast.kind} is not implemented yet`);
     }
 }
 exports.JsonDataService = JsonDataService;
+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 'booolean':
+            case 'number':
+            case 'string':
+                out = dataType.name;
+                break;
+            case 'integer':
+                out = 'int';
+                break;
+            case 'date':
+            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.