@opra/core 0.1.1 → 0.2.0

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

@@ -1,151 +1,311 @@
 import _ from 'lodash';
-import ruleJudgment from 'rule-judgment';
+import merge from 'putil-merge';
+import { nSQL } from "@nano-sql/core";
+import { BadRequestError, MethodNotAllowedError, ResourceConflictError } from '@opra/exception';
+import { ComplexType, EntityResource } from '@opra/schema';
 import { $parse, ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, Expression, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from '@opra/url';
-import { ResourceConflictError } from '../exception/index.js';
-// Fix invalid importing (with ESM) of rule-judgment package
-const createFilterFn = typeof ruleJudgment === 'function'
-    ? ruleJudgment
-    : ruleJudgment.default;
+import { pathToTree } from '../utils/path-to-tree.js';
+let dbId = 1;
 export 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 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));
+    async get(keyValue, options) {
+        await this._init();
+        const select = this._convertSelect({
+            pick: options?.pick,
+            omit: options?.omit,
+            include: options?.include,
+        });
+        nSQL().useDatabase(this._dbName);
+        const rows = await nSQL(this.resourceName)
+            .query('select', select)
+            .where([this.primaryKey, '=', keyValue])
+            .exec();
+        return unFlatten(rows[0]);
+    }
+    async count(options) {
+        await this._init();
+        nSQL().useDatabase(this._dbName);
+        const rows = await 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);
+        nSQL().useDatabase(this._dbName);
+        const query = 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));
     }
-    create(data, options) {
-        if (this.get(data[this.primaryKey]))
+    async create(data, options) {
+        if (!data[this.primaryKey])
+            throw new BadRequestError({
+                message: 'You must provide primary key value'
+            });
+        await this._init();
+        const keyValue = data[this.primaryKey];
+        nSQL().useDatabase(this._dbName);
+        const rows = await nSQL(this._initData).query('select', [this.primaryKey])
+            .where([this.primaryKey, '=', keyValue])
+            .exec();
+        if (rows.length)
             throw new 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);
+        await nSQL(this._initData).query('upsert', data)
+            .exec();
+        return await this.get(keyValue, options);
+    }
+    async update(keyValue, data, options) {
+        await this._init();
+        nSQL().useDatabase(this._dbName);
+        await nSQL(this._initData)
+            .query('conform rows', (row) => {
+            const out = merge({}, row, { deep: true, clone: true });
+            merge(out, data, { deep: true });
+            return out;
+        })
+            .where([this.primaryKey, '=', keyValue])
+            .exec();
+        await 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();
+        nSQL().useDatabase(this._dbName);
+        let affected = 0;
+        await nSQL(this._initData)
+            .query('conform rows', (row) => {
+            const out = merge({}, row, { deep: true, clone: true });
+            merge(out, data, { deep: true });
+            affected++;
+            return out;
+        })
+            .where(filter)
+            .exec();
+        await nSQL(this._initData).query("rebuild indexes").exec();
+        return affected;
+    }
+    async delete(keyValue) {
+        await this._init();
+        nSQL().useDatabase(this._dbName);
+        const result = await 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);
+        nSQL().useDatabase(this._dbName);
+        const result = await 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 nSQL().createDatabase({
+                id: this._dbName,
+                version: 3,
+                tables: [model]
+            });
+            this._status = 'initialized';
+            if (this._initData) {
+                nSQL().useDatabase(this._dbName);
+                await 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 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 = _.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)
                 }, _.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 = _.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
                 }, _.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 = _.omitBy({
+                        pick: query.pick,
+                        omit: query.omit,
+                        include: query.include
+                    }, _.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 MethodNotAllowedError({
+                        message: '$distinct parameter is not supported by JsonDataService'
+                    });
                 const options = _.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,
                 }, _.isNil);
                 return {
-                    method: query.queryType,
+                    method: query.method,
                     options,
                     args: [options]
                 };
             }
             case 'update': {
                 const options = _.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
                 }, _.isNil);
                 const { data } = query;
                 const keyValue = query.keyValue;
                 return {
-                    method: query.queryType,
+                    method: query.method,
                     keyValue: query.keyValue,
                     values: data,
                     options,
@@ -154,11 +314,11 @@ export class JsonDataService {
             }
             case 'updateMany': {
                 const options = _.omitBy({
-                    filter: JsonDataService.convertFilter(query.filter)
+                    filter: this._convertFilter(query.filter)
                 }, _.isNil);
                 const { data } = query;
                 return {
-                    method: query.queryType,
+                    method: query.method,
                     options,
                     args: [data, options]
                 };
@@ -167,7 +327,7 @@ export class JsonDataService {
                 const options = {};
                 const keyValue = query.keyValue;
                 return {
-                    method: query.queryType,
+                    method: query.method,
                     keyValue,
                     options,
                     args: [keyValue, options]
@@ -175,44 +335,70 @@ export class JsonDataService {
             }
             case 'deleteMany': {
                 const options = _.omitBy({
-                    filter: JsonDataService.convertFilter(query.filter)
+                    filter: this._convertFilter(query.filter)
                 }, _.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 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 ? pathToTree(args.pick, true) : undefined), (args.omit ? pathToTree(args.omit, true) : undefined), (args.include ? pathToTree(args.include, true) : undefined));
+        return result;
     }
-    static convertFilter(str) {
+    _convertFilter(str) {
         const ast = typeof str === 'string'
             ? $parse(str)
             : str;
         if (!ast || !(ast instanceof Expression))
             return ast;
         if (ast instanceof 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`);
             }
@@ -229,19 +415,69 @@ export class JsonDataService {
             return ast.value;
         }
         if (ast instanceof ArrayExpression) {
-            return ast.items.map(JsonDataService.convertFilter);
+            return ast.items.map(item => this._convertFilter(item));
         }
         if (ast instanceof 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 ArrayExpression) {
-            return ast.items.map(JsonDataService.convertFilter);
+            return ast.items.map(item => this._convertFilter(item));
         }
         if (ast instanceof ParenthesesExpression) {
-            return JsonDataService.convertFilter(ast.expression);
+            return this._convertFilter(ast.expression);
+        }
+        throw new Error(`${ast.kind} is not implemented yet`);
+    }
+}
+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;
         }
-        throw new Error(`${ast.type} is not implemented yet`);
     }
+    return out + (isArray ? '[]' : '');
 }

package/esm/types.d.ts

@@ -1,7 +1,4 @@
 import { Builtin, DeepPickWritable } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-export declare type QueryType = OpraSchema.EntityMethodType | 'schema' | 'execute';
-export declare type KeyValue = string | number | boolean | object;
 export declare type EntityInput<T> = DeepNullableIfPartial<DeepPickWritable<T>>;
 export declare type EntityOutput<T> = DeepNullableIfPartial<T>;
 export declare type DeepNullableIfPartial<T> = _DeepNullableIfPartial<T>;

package/esm/utils/path-to-tree.d.ts

@@ -1,4 +1,4 @@
 export interface ObjectTree {
     [key: string]: boolean | ObjectTree;
 }
-export declare function pathToTree(arr: string[]): ObjectTree | undefined;
+export declare function pathToTree(arr: string[], lowerCaseKeys?: boolean): ObjectTree | undefined;

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

@@ -1,18 +1,20 @@
 const dotPattern = /^([^.]+)\.(.*)$/;
-export function pathToTree(arr) {
+export function pathToTree(arr, lowerCaseKeys) {
     if (!arr.length)
         return;
-    return _stringPathToObjectTree(arr, {});
+    return _pathToTree(arr, {}, lowerCaseKeys);
 }
-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/i18n/en/error.json

@@ -3,13 +3,13 @@
   "FAILED_DEPENDENCY": "The request failed due to failure of a previous request",
   "FORBIDDEN": "You are not authorized to perform this action",
   "INTERNAL_SERVER_ERROR": "Internal server error",
-  "METHOD_NOT_ALLOWED": "Method Not Allowed",
-  "NOT_ACCEPTABLE": "Not Acceptable",
+  "METHOD_NOT_ALLOWED": "Method not allowed",
+  "NOT_ACCEPTABLE": "Not acceptable",
   "NOT_FOUND": "Not found",
   "UNAUTHORIZED": "You have not been authenticated to perform this action",
   "UNPROCESSABLE_ENTITY": "Unprocessable entity",
-
-  "RESOLVER_FORBIDDEN": "The resource endpoint does not accept '{{queryType}}' operations",
   "RESOURCE_NOT_FOUND": "The resource '{{resource}}' could not be found",
-  "RESOURCE_CONFLICT": "There is already an other {{resource}} resource with same field values ({{fields}})"
+  "RESOURCE_CONFLICT": "There is already an other {{resource}} resource with same field values ({{fields}})",
+  "RESOLVER_FORBIDDEN": "The resource endpoint does not accept '{{method}}' operations",
+  "UNACCEPTED_SORT_FIELD": "Field '{{field}}' is not available for sort operation"
 }