@opra/core 0.1.1 → 0.3.0

package/esm/services/json-collection-service.d.ts

@@ -0,0 +1,85 @@
+import { Maybe } from 'ts-gems';
+import { ComplexType, EntityResource, OpraAnyQuery, OpraSchema } from '@opra/schema';
+import { Expression } from '@opra/url';
+import { QueryContext } from '../implementation/query-context.js';
+import { IEntityService } from '../interfaces/entity-service.interface.js';
+import { EntityInput, EntityOutput } from '../types.js';
+export interface JsonCollectionServiceOptions {
+    resourceName?: string;
+    defaultLimit?: number;
+    data?: any[];
+}
+export declare class JsonCollectionService<T, TOutput = EntityOutput<T>> implements IEntityService {
+    readonly resource: EntityResource;
+    private _status;
+    private _initError;
+    private _dbName;
+    private _initData?;
+    defaultLimit: number;
+    constructor(resource: EntityResource, options?: JsonCollectionServiceOptions);
+    get dataType(): ComplexType;
+    get primaryKey(): string;
+    get resourceName(): string;
+    close(): Promise<void>;
+    processRequest(ctx: QueryContext): Promise<any>;
+    get(keyValue: any, options?: JsonCollectionService.GetOptions): Promise<Maybe<TOutput>>;
+    count(options?: JsonCollectionService.SearchOptions): Promise<number>;
+    search(options?: JsonCollectionService.SearchOptions): Promise<TOutput[]>;
+    create(data: EntityInput<T>, options?: JsonCollectionService.CreateOptions): Promise<TOutput>;
+    update(keyValue: any, data: EntityInput<T>, options?: JsonCollectionService.UpdateOptions): Promise<Maybe<TOutput>>;
+    updateMany(data: EntityInput<T>, options?: JsonCollectionService.UpdateManyOptions): Promise<number>;
+    delete(keyValue: any): Promise<boolean>;
+    deleteMany(options?: JsonCollectionService.DeleteManyOptions): Promise<number>;
+    private _waitInitializing;
+    protected _init(): Promise<void>;
+    protected _prepare(query: OpraAnyQuery): {
+        method: OpraSchema.EntityMethod;
+        options: any;
+        keyValue?: any;
+        values?: any;
+        args: any[];
+    };
+    protected _convertSelect(args: {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    }): string[];
+    protected _convertFilter(str: string | Expression | undefined | {}): any;
+}
+export declare namespace JsonCollectionService {
+    type CountOptions = {
+        filter?: string | Expression | {};
+    };
+    type CreateOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type GetOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type SearchOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+        filter?: any[];
+        sort?: string[];
+        limit?: number;
+        skip?: number;
+        distinct?: boolean;
+        count?: boolean;
+    };
+    type UpdateOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type UpdateManyOptions = {
+        filter?: any[];
+    };
+    type DeleteManyOptions = {
+        filter?: any[];
+    };
+}

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

@@ -0,0 +1,500 @@
+import _ from 'lodash';
+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 { pathToTree } from '../utils/path-to-tree.js';
+let dbId = 1;
+const indexingTypes = ['int', 'float', 'number', 'date', 'string'];
+export 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 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,
+        });
+        nSQL().useDatabase(this._dbName);
+        try {
+            const rows = await 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();
+        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));
+    }
+    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.resourceName).query('select', [this.primaryKey])
+            .where([this.primaryKey, '=', keyValue])
+            .exec();
+        if (rows.length)
+            throw new ResourceConflictError(this.resourceName, this.primaryKey);
+        await nSQL(this.resourceName).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.resourceName)
+            .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.resourceName).query("rebuild indexes").exec();
+        return this.get(keyValue, options);
+    }
+    async updateMany(data, options) {
+        await this._init();
+        const filter = this._convertFilter(options?.filter);
+        nSQL().useDatabase(this._dbName);
+        let affected = 0;
+        await nSQL(this.resourceName)
+            .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.resourceName).query("rebuild indexes").exec();
+        return affected;
+    }
+    async delete(keyValue) {
+        await this._init();
+        nSQL().useDatabase(this._dbName);
+        const result = await 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);
+        nSQL().useDatabase(this._dbName);
+        const result = await 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 nSQL().createDatabase({
+                id: this._dbName,
+                version: 3,
+                tables: [table]
+            });
+            this._status = 'initialized';
+            if (this._initData) {
+                nSQL().useDatabase(this._dbName);
+                await 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 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({
+                    filter: this._convertFilter(query.filter)
+                }, _.isNil);
+                return {
+                    method: query.method,
+                    options,
+                    args: [options]
+                };
+            }
+            case 'create': {
+                const options = _.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
+                }, _.isNil);
+                const { data } = query;
+                return {
+                    method: query.method,
+                    values: data,
+                    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,
+                    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,
+                }, _.isNil);
+                return {
+                    method: query.method,
+                    options,
+                    args: [options]
+                };
+            }
+            case 'update': {
+                const options = _.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
+                }, _.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 = _.omitBy({
+                    filter: this._convertFilter(query.filter)
+                }, _.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 = _.omitBy({
+                    filter: this._convertFilter(query.filter)
+                }, _.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 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;
+    }
+    _convertFilter(str) {
+        const ast = typeof str === 'string'
+            ? $parse(str)
+            : str;
+        if (!ast || !(ast instanceof Expression))
+            return ast;
+        if (ast instanceof 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 QualifiedIdentifier) {
+            return ast.value;
+        }
+        if (ast instanceof NumberLiteral ||
+            ast instanceof StringLiteral ||
+            ast instanceof BooleanLiteral ||
+            ast instanceof NullLiteral ||
+            ast instanceof DateLiteral ||
+            ast instanceof TimeLiteral) {
+            return ast.value;
+        }
+        if (ast instanceof ArrayExpression) {
+            return ast.items.map(item => this._convertFilter(item));
+        }
+        if (ast instanceof 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 ArrayExpression) {
+            return ast.items.map(item => this._convertFilter(item));
+        }
+        if (ast instanceof ParenthesesExpression) {
+            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 '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/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"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -27,21 +27,24 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/i18n": "^0.1.1",
-    "@opra/optionals": "^0.1.1",
-    "@opra/schema": "^0.1.1",
-    "@opra/url": "^0.1.1",
+    "@opra/exception": "^0.3.0",
+    "@opra/i18n": "^0.3.0",
+    "@opra/optionals": "^0.3.0",
+    "@opra/schema": "^0.3.0",
+    "@opra/url": "^0.3.0",
+    "@nano-sql/core": "^2.3.7",
+    "express": "^4.18.1",
+    "body-parser": "^1.20.1",
     "lodash": "^4.17.21",
     "putil-isplainobject": "^1.1.4",
     "putil-varhelpers": "^1.6.4",
     "putil-merge": "^3.9.0",
-    "rule-judgment": "^1.1.5",
     "strict-typed-events": "^2.2.0",
     "ts-gems": "^2.2.0"
   },
   "devDependencies": {
     "@types/express": "^4.17.14",
-    "express": "^4.18.1"
+    "@faker-js/faker": "^7.5.0"
   },
   "type": "module",
   "types": "esm/index.d.ts",