@opra/core 0.10.0 → 0.12.0

package/esm/index.d.ts

@@ -8,5 +8,4 @@ export * from './adapter/adapter.js';
 export * from './adapter/http-adapter.js';
 export * from './adapter/express-adapter.js';
 export * from './services/data-service.js';
-export * from './services/json-collection-service.js';
 export * from './services/json-singleton-service.js';

package/esm/index.js

@@ -8,5 +8,4 @@ export * from './adapter/adapter.js';
 export * from './adapter/http-adapter.js';
 export * from './adapter/express-adapter.js';
 export * from './services/data-service.js';
-export * from './services/json-collection-service.js';
 export * from './services/json-singleton-service.js';

package/esm/interfaces/execution-context.interface.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 import { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http';
 import { Readable, Writable } from 'stream';
-export declare type ContextType = 'http' | 'ws' | 'rpc';
+export type ContextType = 'http' | 'ws' | 'rpc';
 export declare namespace IExecutionContext {
     type OnFinishArgs = {
         userContext: any;

package/esm/interfaces/logger.interface.d.ts

@@ -0,0 +1,7 @@
+export interface ILogger {
+    log(message: any, ...optionalParams: any[]): any;
+    error(message: any, ...optionalParams: any[]): any;
+    warn(message: any, ...optionalParams: any[]): any;
+    debug?(message: any, ...optionalParams: any[]): any;
+    verbose?(message: any, ...optionalParams: any[]): any;
+}

package/esm/interfaces/logger.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/resource.interface.d.ts

@@ -3,6 +3,7 @@ import { ResourceInfo } from '@opra/common';
 import { PartialOutput } from '../types.js';
 export interface IResource {
     init?(resource: ResourceInfo): void | Promise<void>;
+    shutDown?(): void | Promise<void>;
 }
 export interface ICollectionResource<T, TOutput = PartialOutput<T>> extends IResource {
     create?(...args: any[]): TOutput | Promise<TOutput>;

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

@@ -1,4 +1,5 @@
-import { isNil, omitBy } from 'lodash';
+import isNil from 'lodash.isnil';
+import omitBy from 'lodash.omitby';
 import { SingletonResourceInfo } from '@opra/common';
 export class JsonSingletonService {
     constructor(dataType, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -19,32 +19,33 @@
     "_copy_pkg_files": "cp README.md package.json ../../LICENSE ../../build/core && cp ../../package.cjs.json ../../build/core/cjs/package.json",
     "_copyi18n": "cp -R i18n ../../build/core/i18n",
     "lint": "eslint . --max-warnings=0",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
+    "test": "NODE_OPTIONS=--experimental-vm-modules npx jest",
+    "cover": "NODE_OPTIONS=--experimental-vm-modules npx jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
-    "clean:src": "ts-cleanup -s src --all",
+    "clean:src": "ts-cleanup -s src --all && ts-cleanup -s test --all",
     "clean:dist": "rimraf ../../build/core",
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@nano-sql/core": "^2.3.7",
-    "@opra/common": "^0.10.0",
-    "body-parser": "^1.20.1",
-    "dicer": "^0.3.1",
-    "express": "^4.18.2",
-    "http-parser-js": "^0.5.8",
-    "lodash": "^4.17.21",
-    "power-tasks": "^1.6.1",
-    "putil-isplainobject": "^1.1.4",
-    "putil-merge": "^3.9.0",
-    "putil-varhelpers": "^1.6.4",
-    "strict-typed-events": "^2.3.1",
-    "ts-gems": "^2.3.0"
+    "@opra/common": "^0.12.0",
+    "lodash.isnil": "^4.0.0",
+    "lodash.omitby": "^4.6.0",
+    "power-tasks": "^1.6.4",
+    "putil-isplainobject": "^1.1.5",
+    "putil-merge": "^3.10.1",
+    "putil-varhelpers": "^1.6.5",
+    "strict-typed-events": "^2.3.1"
+  },
+  "peerDependencies": {
+    "body-parser": ">= 1.0.0",
+    "express": "^4.x.x || ^5.x.x"
   },
   "devDependencies": {
     "@faker-js/faker": "^7.6.0",
     "@types/dicer": "^0.2.2",
-    "@types/express": "^4.17.14"
+    "@types/express": "^4.17.16",
+    "cors": "^2.8.5",
+    "ts-gems": "^2.3.0"
   },
   "type": "module",
   "types": "esm/index.d.ts",
@@ -79,4 +80,4 @@
     "http",
     "web"
   ]
-}
+}

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

@@ -1,497 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonCollectionService = void 0;
-const tslib_1 = require("tslib");
-const lodash_1 = require("lodash");
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
-const core_1 = require("@nano-sql/core");
-const common_1 = require("@opra/common");
-let dbId = 1;
-const indexingTypes = ['int', 'float', 'number', 'date', 'string'];
-class JsonCollectionService {
-    constructor(resource, options) {
-        this.resource = resource;
-        this._status = '';
-        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 common_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 common_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.document.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 searchResolver = this.resource.metadata.search;
-            if (searchResolver) {
-                if (searchResolver.sortFields) {
-                    searchResolver.sortFields.forEach(fieldName => {
-                        const f = this.dataType.getField(fieldName);
-                        const fieldType = this.resource.document.getDataType(f.type || 'string');
-                        const t = dataTypeToSQLType(fieldType, !!f.isArray);
-                        if (indexingTypes.includes(t))
-                            indexes[fieldName + ':' + t] = {};
-                    });
-                }
-                if (searchResolver.filters) {
-                    searchResolver.filters.forEach(filter => {
-                        const f = this.dataType.getField(filter.field);
-                        const fieldType = this.resource.document.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 common_1.CollectionResourceInfo) {
-            if (query.dataType !== this.dataType)
-                throw new TypeError(`Query data type (${query.dataType.name}) ` +
-                    `differs from JsonCollectionService data type (${this.dataType.name})`);
-        }
-        switch (query.method) {
-            case 'count': {
-                const options = (0, lodash_1.omitBy)({
-                    filter: this._convertFilter(query.filter)
-                }, lodash_1.isNil);
-                return {
-                    method: query.method,
-                    options,
-                    args: [options]
-                };
-            }
-            case 'create': {
-                const options = (0, lodash_1.omitBy)({
-                    pick: query.pick,
-                    omit: query.omit,
-                    include: query.include
-                }, lodash_1.isNil);
-                const { data } = query;
-                return {
-                    method: query.method,
-                    values: data,
-                    options,
-                    args: [data, options]
-                };
-            }
-            case 'get': {
-                if (query.kind === 'CollectionGetQuery') {
-                    const options = (0, lodash_1.omitBy)({
-                        pick: query.pick,
-                        omit: query.omit,
-                        include: query.include
-                    }, lodash_1.isNil);
-                    const keyValue = query.keyValue;
-                    return {
-                        method: query.method,
-                        keyValue,
-                        options,
-                        args: [keyValue, options]
-                    };
-                }
-                if (query.kind === 'FieldGetQuery') {
-                    // todo
-                }
-                break;
-            }
-            case 'search': {
-                if (query.distinct)
-                    throw new common_1.MethodNotAllowedError({
-                        message: '$distinct parameter is not supported by JsonDataService'
-                    });
-                const options = (0, lodash_1.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.isNil);
-                return {
-                    method: query.method,
-                    options,
-                    args: [options]
-                };
-            }
-            case 'update': {
-                const options = (0, lodash_1.omitBy)({
-                    pick: query.pick,
-                    omit: query.omit,
-                    include: query.include
-                }, lodash_1.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 = (0, lodash_1.omitBy)({
-                    filter: this._convertFilter(query.filter)
-                }, lodash_1.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 = (0, lodash_1.omitBy)({
-                    filter: this._convertFilter(query.filter)
-                }, lodash_1.isNil);
-                return {
-                    method: query.method,
-                    options,
-                    args: [options]
-                };
-            }
-        }
-        throw new Error(`Unimplemented query type "${query.method}"`);
-    }
-    _convertSelect(args) {
-        const result = [];
-        const document = this.dataType.document;
-        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 common_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, common_1.pathToTree)(args.pick, true) : undefined), (args.omit ? (0, common_1.pathToTree)(args.omit, true) : undefined), (args.include ? (0, common_1.pathToTree)(args.include, true) : undefined));
-        return result;
-    }
-    _convertFilter(str) {
-        const ast = typeof str === 'string'
-            ? (0, common_1.parseFilter)(str)
-            : str;
-        if (!ast || !(ast instanceof common_1.Expression))
-            return ast;
-        if (ast instanceof common_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 common_1.QualifiedIdentifier) {
-            return ast.value;
-        }
-        if (ast instanceof common_1.NumberLiteral ||
-            ast instanceof common_1.StringLiteral ||
-            ast instanceof common_1.BooleanLiteral ||
-            ast instanceof common_1.NullLiteral ||
-            ast instanceof common_1.DateLiteral ||
-            ast instanceof common_1.TimeLiteral) {
-            return ast.value;
-        }
-        if (ast instanceof common_1.ArrayExpression) {
-            return ast.items.map(item => this._convertFilter(item));
-        }
-        if (ast instanceof common_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 common_1.ArrayExpression) {
-            return ast.items.map(item => this._convertFilter(item));
-        }
-        if (ast instanceof common_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 ? '[]' : '');
-}