@opra/core 0.2.0 → 0.4.0

package/cjs/services/{json-data-service.js → json-collection-service.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonDataService = void 0;
+exports.JsonCollectionService = void 0;
 const tslib_1 = require("tslib");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
@@ -10,7 +10,8 @@ const schema_1 = require("@opra/schema");
 const url_1 = require("@opra/url");
 const path_to_tree_js_1 = require("../utils/path-to-tree.js");
 let dbId = 1;
-class JsonDataService {
+const indexingTypes = ['int', 'float', 'number', 'date', 'string'];
+class JsonCollectionService {
     resource;
     _status = '';
     _initError;
@@ -19,6 +20,8 @@ class JsonDataService {
     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;
     }
@@ -26,7 +29,7 @@ class JsonDataService {
         return this.resource.dataType;
     }
     get primaryKey() {
-        return this.resource.dataType.primaryKey;
+        return this.resource.keyFields[0];
     }
     get resourceName() {
         return this.resource.name;
@@ -59,11 +62,16 @@ class JsonDataService {
             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]);
+        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();
@@ -99,19 +107,19 @@ class JsonDataService {
         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])
+        const rows = await (0, core_1.nSQL)(this.resourceName).query('select', [this.primaryKey])
             .where([this.primaryKey, '=', keyValue])
             .exec();
         if (rows.length)
             throw new exception_1.ResourceConflictError(this.resourceName, this.primaryKey);
-        await (0, core_1.nSQL)(this._initData).query('upsert', data)
+        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._initData)
+        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 });
@@ -119,16 +127,15 @@ class JsonDataService {
         })
             .where([this.primaryKey, '=', keyValue])
             .exec();
-        await (0, core_1.nSQL)(this._initData).query("rebuild indexes").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);
-        await this._init();
         (0, core_1.nSQL)().useDatabase(this._dbName);
         let affected = 0;
-        await (0, core_1.nSQL)(this._initData)
+        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 });
@@ -137,13 +144,13 @@ class JsonDataService {
         })
             .where(filter)
             .exec();
-        await (0, core_1.nSQL)(this._initData).query("rebuild indexes").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._initData)
+        const result = await (0, core_1.nSQL)(this.resourceName)
             .query('delete')
             .where([this.primaryKey, '=', keyValue])
             .exec();
@@ -153,7 +160,7 @@ class JsonDataService {
         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)
+        const result = await (0, core_1.nSQL)(this.resourceName)
             .query('delete')
             .where(filter)
             .exec();
@@ -182,36 +189,45 @@ class JsonDataService {
         this._status = 'initializing';
         this._dbName = 'JsonDataService_DB_' + (dbId++);
         try {
-            const model = {
+            const table = {
                 name: this.resourceName,
-                model: {
-                    '*:any': {}
-                },
-                indexes: {},
-                primaryKey: this.primaryKey
+                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 searchMethod = this.resource.metadata.methods.search;
-            if (searchMethod) {
-                if (searchMethod.sortFields) {
-                    searchMethod.sortFields.forEach(fieldName => {
+            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.owner.getDataType(f.type || 'string');
-                        model.indexes[fieldName + ':' + dataTypeToSQLType(fieldType, !!f.isArray)] = {};
+                        const fieldType = this.resource.document.getDataType(f.type || 'string');
+                        const t = dataTypeToSQLType(fieldType, !!f.isArray);
+                        if (indexingTypes.includes(t))
+                            indexes[fieldName + ':' + t] = {};
                     });
                 }
-                if (searchMethod.filters) {
-                    searchMethod.filters.forEach(filter => {
+                if (searchResolver.filters) {
+                    searchResolver.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)] = {};
+                        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: [model]
+                tables: [table]
             });
             this._status = 'initialized';
             if (this._initData) {
@@ -225,13 +241,14 @@ class JsonDataService {
         catch (e) {
             this._initError = e;
             this._status = 'error';
+            throw e;
         }
     }
     _prepare(query) {
-        if (query.resource instanceof schema_1.EntityResource) {
+        if (query.resource instanceof schema_1.CollectionResourceInfo) {
             if (query.dataType !== this.dataType)
                 throw new TypeError(`Query data type (${query.dataType.name}) ` +
-                    `differs from JsonDataService data type (${this.dataType.name})`);
+                    `differs from JsonCollectionService data type (${this.dataType.name})`);
         }
         switch (query.method) {
             case 'count': {
@@ -259,7 +276,7 @@ class JsonDataService {
                 };
             }
             case 'get': {
-                if (query.kind === 'GetInstanceQuery') {
+                if (query.kind === 'CollectionGetQuery') {
                     const options = lodash_1.default.omitBy({
                         pick: query.pick,
                         omit: query.omit,
@@ -273,7 +290,7 @@ class JsonDataService {
                         args: [keyValue, options]
                     };
                 }
-                if (query.kind === 'GetFieldQuery') {
+                if (query.kind === 'FieldGetQuery') {
                     // todo
                 }
                 break;
@@ -352,7 +369,7 @@ class JsonDataService {
     }
     _convertSelect(args) {
         const result = [];
-        const document = this.dataType.owner;
+        const document = this.dataType.document;
         const processDataType = (dt, path, pick, omit, include) => {
             let kl;
             for (const [k, f] of dt.fields) {
@@ -439,7 +456,7 @@ class JsonDataService {
         throw new Error(`${ast.kind} is not implemented yet`);
     }
 }
-exports.JsonDataService = JsonDataService;
+exports.JsonCollectionService = JsonCollectionService;
 function unFlatten(input) {
     if (!input)
         return;
@@ -464,7 +481,7 @@ function dataTypeToSQLType(dataType, isArray) {
         out = 'object';
     else {
         switch (dataType.name) {
-            case 'booolean':
+            case 'boolean':
             case 'number':
             case 'string':
                 out = dataType.name;
@@ -472,10 +489,10 @@ function dataTypeToSQLType(dataType, isArray) {
             case 'integer':
                 out = 'int';
                 break;
-            case 'date':
-            case 'date-time':
-                out = 'date';
-                break;
+            // case 'date': //there is bug in nano-sql.
+            // case 'date-time':
+            //   out = 'date';
+            //   break;
             case 'time':
                 out = 'string';
                 break;

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSingletonService = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const schema_1 = require("@opra/schema");
+class JsonSingletonService {
+    dataType;
+    _data;
+    constructor(dataType, options) {
+        this.dataType = dataType;
+        this._data = options?.data;
+    }
+    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);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    get(options) {
+        return this._data;
+    }
+    _prepare(query) {
+        if (query.resource instanceof schema_1.SingletonResourceInfo) {
+            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 'create': {
+                const options = lodash_1.default.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
+                }, lodash_1.default.isNil);
+                const { data } = query;
+                return {
+                    method: query.method,
+                    values: data,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'get': {
+                if (query.kind === 'CollectionGetQuery') {
+                    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 === 'FieldGetQuery') {
+                    // todo
+                }
+                break;
+            }
+            case 'update': {
+                const options = lodash_1.default.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
+                }, lodash_1.default.isNil);
+                const { data } = query;
+                const keyValue = query.keyValue;
+                return {
+                    method: query.method,
+                    keyValue: query.keyValue,
+                    values: data,
+                    options,
+                    args: [keyValue, data, options]
+                };
+            }
+            case 'delete': {
+                const options = {};
+                const keyValue = query.keyValue;
+                return {
+                    method: query.method,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+        }
+        throw new Error(`Unimplemented query type "${query.method}"`);
+    }
+}
+exports.JsonSingletonService = JsonSingletonService;

package/esm/{implementation → adapter}/adapter.d.ts

@@ -1,6 +1,7 @@
+import { ResponsiveMap } from '@opra/common';
 import { OpraException } from '@opra/exception';
 import { FallbackLng, I18n, LanguageResource } from '@opra/i18n';
-import { OpraService } from '@opra/schema';
+import { CollectionGetQuery, CollectionResourceInfo, ComplexType, DataType, FieldGetQuery, OpraDocument, ResourceInfo, SingletonGetQuery, SingletonResourceInfo } from '@opra/schema';
 import { IExecutionContext } from '../interfaces/execution-context.interface.js';
 import { QueryContext } from './query-context.js';
 export declare namespace OpraAdapter {
@@ -41,17 +42,24 @@ export declare namespace OpraAdapter {
     }
 }
 export declare abstract class OpraAdapter<TExecutionContext extends IExecutionContext> {
-    readonly service: OpraService;
-    readonly i18n: I18n;
-    readonly userContextResolver?: OpraAdapter.UserContextResolver;
-    constructor(service: OpraService, options?: Omit<OpraAdapter.Options, 'i18n'> & {
-        i18n: I18n;
-    });
+    readonly document: OpraDocument;
+    protected i18n: I18n;
+    protected userContextResolver?: OpraAdapter.UserContextResolver;
+    protected _internalResources: ResponsiveMap<string, ResourceInfo>;
+    constructor(document: OpraDocument);
     protected abstract prepareRequests(executionContext: TExecutionContext): QueryContext[];
     protected abstract sendResponse(executionContext: TExecutionContext, queryContexts: QueryContext[]): Promise<void>;
     protected abstract sendError(executionContext: TExecutionContext, error: OpraException): Promise<void>;
     protected abstract isBatch(executionContext: TExecutionContext): boolean;
     protected handler(executionContext: TExecutionContext): Promise<void>;
-    protected _getSchemaExecute(ctx: QueryContext): Promise<void>;
-    protected static initI18n(options?: OpraAdapter.Options): Promise<I18n>;
+    protected _resourcePrepare(resource: ResourceInfo, context: QueryContext): Promise<void>;
+    protected _resourceExecute(document: OpraDocument, resource: ResourceInfo, context: QueryContext): Promise<void>;
+    protected _init(options?: OpraAdapter.Options): Promise<void>;
+    protected _collectionResourceExecute(document: OpraDocument, resource: CollectionResourceInfo, context: QueryContext): Promise<any>;
+    protected _singletonResourceExecute(document: OpraDocument, resource: SingletonResourceInfo, context: QueryContext): Promise<any>;
+    protected _pathWalkThrough(query: CollectionGetQuery | SingletonGetQuery | FieldGetQuery, dataType: ComplexType, value: any, parentPath: string): Promise<{
+        value?: any;
+        dataType?: DataType;
+        path: string;
+    }>;
 }