@opra/core 0.0.12 → 0.1.0

package/esm/interfaces/query.interface.js

@@ -1,6 +1,6 @@
 import _ from 'lodash';
-import { ComplexType } from '../implementation/data-type/complex-type.js';
-import { stringPathToObjectTree } from '../utils/string-path-to-object-tree.js';
+import { ComplexType } from '@opra/schema';
+import { pathToTree } from '../utils/path-to-tree.js';
 export var OpraQuery;
 (function (OpraQuery) {
     function forCreate(resource, values, options) {
@@ -21,7 +21,24 @@ export var OpraQuery;
         return out;
     }
     OpraQuery.forCreate = forCreate;
-    function forGet(resource, key, options) {
+    function forGetSchema(resourcePath, options) {
+        // if (options?.pick)
+        //   options.pick = normalizePick(resource, options.pick);
+        // if (options?.omit)
+        //   options.omit = normalizePick(resource, options.omit);
+        // if (options?.include)
+        //   options.include = normalizePick(resource, options.include);
+        const out = {
+            queryType: 'schema',
+            scope: 'instance',
+            resourcePath,
+            operation: 'read',
+        };
+        Object.assign(out, _.omit(options, Object.keys(out)));
+        return out;
+    }
+    OpraQuery.forGetSchema = forGetSchema;
+    function forGetEntity(resource, key, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
         if (options?.omit)
@@ -39,7 +56,7 @@ export var OpraQuery;
         Object.assign(out, _.omit(options, Object.keys(out)));
         return out;
     }
-    OpraQuery.forGet = forGet;
+    OpraQuery.forGetEntity = forGetEntity;
     function forSearch(resource, options) {
         if (options?.pick)
             options.pick = normalizePick(resource, options.pick);
@@ -147,19 +164,19 @@ function checkKeyFields(resource, key) {
         throw new Error(`"${resource.name}" has no primary key`);
 }
 function normalizePick(resource, fields) {
-    const fieldsTree = stringPathToObjectTree(fields) || {};
+    const fieldsTree = pathToTree(fields) || {};
     return _normalizeFieldsList([], resource.service, resource, resource.dataType, fieldsTree, '', {
-        additionalProperties: true
+        additionalFields: true
     });
 }
 function _normalizeFieldsList(target, service, resource, dataType, node, parentPath = '', options) {
     let curPath = '';
     for (const k of Object.keys(node)) {
         const nodeVal = node[k];
-        const prop = dataType?.properties?.[k];
+        const prop = dataType?.fields.get(k);
         if (!prop) {
             curPath = parentPath ? parentPath + '.' + k : k;
-            if (!options?.additionalProperties || (dataType && !dataType.additionalProperties))
+            if (!options?.additionalFields || (dataType && !dataType.additionalFields))
                 throw new TypeError(`Unknown field path "${resource.name + '.' + curPath}"`);
             if (typeof nodeVal === 'object')
                 _normalizeFieldsList(target, service, resource, undefined, nodeVal, curPath, options);
@@ -170,7 +187,7 @@ function _normalizeFieldsList(target, service, resource, dataType, node, parentP
         curPath = parentPath ? parentPath + '.' + prop.name : prop.name;
         const propType = service.getDataType(prop.type || 'string');
         if (typeof nodeVal === 'object') {
-            if (!(propType instanceof ComplexType))
+            if (!(propType && propType instanceof ComplexType))
                 throw new TypeError(`"${curPath}" is not a complex type and has no sub fields`);
             if (target.findIndex(x => x === parentPath) >= 0)
                 continue;

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

@@ -1,9 +1,68 @@
-import { DataService } from './data-service.js';
-export interface JsonDataServiceAgs {
-    data: any[];
-    primaryKey: string | string[];
+import { Maybe } from 'ts-gems';
+import { Expression } from '@opra/url';
+import { QueryContext } from '../implementation/query-context.js';
+import { IEntityService } from '../interfaces/entity-service.interface.js';
+import { OpraQuery } from '../interfaces/query.interface.js';
+import { EntityInput, EntityOutput, QueryType } from '../types.js';
+export interface JsonDataServiceAgs<T> {
+    resourceName: string;
+    data: T[];
+    primaryKey: string;
 }
-export declare class JsonDataService extends DataService {
-    data: any[];
-    constructor(args: JsonDataServiceAgs);
+export declare namespace JsonDataService {
+    type GetOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type SearchOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+        limit?: number;
+        skip?: number;
+        distinct?: boolean;
+        total?: boolean;
+        filter?: string | Expression | {};
+    };
+    type CreateOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type UpdateOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type UpdateManyOptions = {
+        filter?: string | Expression | {};
+    };
+    type DeleteManyOptions = {
+        filter?: string | Expression | {};
+    };
+}
+export declare class JsonDataService<T, TOutput = EntityOutput<T>> implements IEntityService {
+    resourceName: string;
+    data: T[];
+    primaryKey: string;
+    constructor(args: JsonDataServiceAgs<T>);
+    processRequest(ctx: QueryContext): any;
+    get(keyValue: any, options?: JsonDataService.GetOptions): Maybe<TOutput>;
+    count(options?: JsonDataService.SearchOptions): Maybe<number>;
+    search(options?: JsonDataService.SearchOptions): Maybe<TOutput>[];
+    create(data: EntityInput<T>, options?: JsonDataService.CreateOptions): TOutput;
+    update(keyValue: any, data: EntityInput<T>, options?: JsonDataService.UpdateOptions): Maybe<TOutput>;
+    updateMany(data: EntityInput<T>, options?: JsonDataService.UpdateManyOptions): number;
+    delete(keyValue: any): boolean;
+    deleteMany(options?: JsonDataService.DeleteManyOptions): number;
+    static filterFields(obj: any, pick: string[] | undefined, omit: string[] | undefined, include: string[] | undefined): any;
+    static prepare(query: OpraQuery): {
+        method: QueryType;
+        options: any;
+        keyValue?: any;
+        values?: any;
+        args: any[];
+    };
+    static convertFilter(str: string | Expression | undefined | {}): any;
 }

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

@@ -1,10 +1,247 @@
+import _ from 'lodash';
 import ruleJudgment from 'rule-judgment';
-import { DataService } from './data-service.js';
+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 toArrayFilter = typeof ruleJudgment === 'function' ? ruleJudgment : ruleJudgment.default;
-export class JsonDataService extends DataService {
+const createFilterFn = typeof ruleJudgment === 'function'
+    ? ruleJudgment
+    : ruleJudgment.default;
+export class JsonDataService {
+    resourceName;
     data;
+    primaryKey;
     constructor(args) {
-        super();
+        this.resourceName = args.resourceName;
+        this.data = args.data;
+        this.primaryKey = args.primaryKey;
+    }
+    processRequest(ctx) {
+        const prepared = JsonDataService.prepare(ctx.query);
+        const fn = this[prepared.method];
+        if (!fn)
+            throw new TypeError(`Unimplemented method (${prepared.method})`);
+        return fn.apply(this, prepared.args);
+    }
+    get(keyValue, options) {
+        const primaryKey = this.primaryKey;
+        let v = this.data.find(x => '' + x[primaryKey] === '' + keyValue);
+        v = JsonDataService.filterFields(v, options?.pick, options?.omit, options?.include);
+        return v;
+    }
+    count(options) {
+        return this.search(options).length;
+    }
+    search(options) {
+        let out;
+        if (options?.filter) {
+            const filter = JsonDataService.convertFilter(options.filter);
+            const filterFn = createFilterFn(filter);
+            out = this.data.filter(filterFn);
+        }
+        else
+            out = this.data;
+        return out.map(v => JsonDataService.filterFields(v, options?.pick, options?.omit, options?.include));
+    }
+    create(data, options) {
+        if (this.get(data[this.primaryKey]))
+            throw new 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);
+        }
+    }
+    updateMany(data, options) {
+        const items = this.search({ filter: options?.filter });
+        for (let i = 0; i < items.length; i++) {
+            Object.assign(items[i], data);
+        }
+        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;
+        }
+        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': {
+                const options = _.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                }, _.isNil);
+                const { data } = query;
+                return {
+                    method: query.queryType,
+                    values: data,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'get': {
+                const options = _.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                }, _.isNil);
+                const keyValue = query.keyValue;
+                return {
+                    method: query.queryType,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+            case 'search': {
+                const options = _.omitBy({
+                    pick: query.pick?.length ? query.pick : undefined,
+                    omit: query.omit?.length ? query.omit : undefined,
+                    include: query.include?.length ? query.include : undefined,
+                    sort: query.sort?.length ? query.sort : undefined,
+                    limit: query.limit,
+                    offset: query.skip,
+                    distinct: query.distinct,
+                    total: query.count,
+                    filter: JsonDataService.convertFilter(query.filter)
+                }, _.isNil);
+                return {
+                    method: query.queryType,
+                    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,
+                }, _.isNil);
+                const { data } = query;
+                const keyValue = query.keyValue;
+                return {
+                    method: query.queryType,
+                    keyValue: query.keyValue,
+                    values: data,
+                    options,
+                    args: [keyValue, data, options]
+                };
+            }
+            case 'updateMany': {
+                const options = _.omitBy({
+                    filter: JsonDataService.convertFilter(query.filter)
+                }, _.isNil);
+                const { data } = query;
+                return {
+                    method: query.queryType,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'delete': {
+                const options = {};
+                const keyValue = query.keyValue;
+                return {
+                    method: query.queryType,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+            case 'deleteMany': {
+                const options = _.omitBy({
+                    filter: JsonDataService.convertFilter(query.filter)
+                }, _.isNil);
+                return {
+                    method: query.queryType,
+                    options,
+                    args: [options]
+                };
+            }
+            default:
+                throw new Error(`Unimplemented query type "${query.queryType}"`);
+        }
+    }
+    static 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);
+            switch (ast.op) {
+                case '=':
+                    return { $eq: { [left]: right } };
+                case '!=':
+                    return { $ne: { [left]: right } };
+                case '>':
+                    return { $gt: { [left]: right } };
+                case '>=':
+                    return { $gte: { [left]: right } };
+                case '<':
+                    return { $lt: { [left]: right } };
+                case '<=':
+                    return { $lte: { [left]: right } };
+                case 'in':
+                    return { $in: { [left]: right } };
+                case '!in':
+                    return { $nin: { [left]: 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(JsonDataService.convertFilter);
+        }
+        if (ast instanceof LogicalExpression) {
+            if (ast.op === 'or')
+                return { $or: ast.items.map(JsonDataService.convertFilter) };
+            return { $and: ast.items.map(JsonDataService.convertFilter) };
+        }
+        if (ast instanceof ArrayExpression) {
+            return ast.items.map(JsonDataService.convertFilter);
+        }
+        if (ast instanceof ParenthesesExpression) {
+            return JsonDataService.convertFilter(ast.expression);
+        }
+        throw new Error(`${ast.type} is not implemented yet`);
     }
 }

package/esm/types.d.ts

@@ -1,9 +1,11 @@
-import type { Type } from 'ts-gems';
-export declare type Thunk<T> = T | (() => T);
-export declare type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
-export declare type TypeThunk<T = any> = Thunk<Type<T>>;
-export declare type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
-export declare type QueryScope = 'collection' | 'instance' | 'property';
-export declare type QueryType = 'create' | 'get' | 'update' | 'patch' | 'delete' | 'execute' | 'search' | 'updateMany' | 'patchMany' | 'deleteMany';
-export declare type OperationType = 'create' | 'read' | 'update' | 'patch' | 'delete' | 'execute';
+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>;
+declare type _DeepNullableIfPartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullableIfPartial<U>> : T extends (infer U)[] ? DeepNullableIfPartial<U>[] : {
+    [P in keyof T]?: DeepNullableIfPartial<Exclude<T[P], undefined>> | null;
+};
+export {};

package/esm/utils/create-i18n.d.ts

@@ -1,3 +1,3 @@
 import { I18n } from '@opra/i18n';
-import { OpraAdapter } from '../implementation/adapter/adapter.js';
+import { OpraAdapter } from '../implementation/adapter.js';
 export declare function createI18n(options?: OpraAdapter.I18nOptions): Promise<I18n>;

package/esm/utils/create-i18n.js

@@ -4,8 +4,8 @@ import { getCallerFile } from './get-caller-file.util.js';
 export async function createI18n(options) {
     const opts = {
         ...options,
-        resourceDirs: undefined
     };
+    delete opts.resourceDirs;
     const instance = I18n.createInstance(opts);
     await instance.init();
     await instance.loadResourceDir(path.resolve(getCallerFile(), '../../../i18n'));

package/esm/utils/get-caller-file.util.d.ts

@@ -1 +1 @@
-export declare function getCallerFile(position?: number): any;
+export declare function getCallerFile(position?: number): string;

package/esm/utils/get-caller-file.util.js

@@ -1,3 +1,4 @@
+const PATH_PATTERN = /^(?:file:\/\/)?(.+)$/;
 export function getCallerFile(position = 1) {
     if (position >= Error.stackTraceLimit) {
         throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
@@ -10,6 +11,10 @@ export function getCallerFile(position = 1) {
     if (stack !== null && typeof stack === 'object') {
         // stack[0] holds this file
         // stack[1] holds where this function was called
-        return stack[position] ? stack[position].getFileName() : undefined;
+        const s = stack[position] ?
+            stack[position].getFileName() : undefined;
+        const m = s ? PATH_PATTERN.exec(s) : undefined;
+        return m ? m[1] : '';
     }
+    return '';
 }

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

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

package/esm/utils/{string-path-to-object-tree.js → path-to-tree.js}

@@ -1,5 +1,5 @@
 const dotPattern = /^([^.]+)\.(.*)$/;
-export function stringPathToObjectTree(arr) {
+export function pathToTree(arr) {
     if (!arr.length)
         return;
     return _stringPathToObjectTree(arr, {});

package/i18n/en/error.json

@@ -4,9 +4,12 @@
   "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",
   "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}})"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.0.12",
+  "version": "0.1.0",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -27,13 +27,14 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/i18n": "^0.0.12",
-    "@opra/optionals": "^0.0.12",
-    "@opra/schema": "^0.0.12",
-    "@opra/url": "^0.0.12",
+    "@opra/i18n": "^0.1.0",
+    "@opra/optionals": "^0.1.0",
+    "@opra/schema": "^0.1.0",
+    "@opra/url": "^0.1.0",
     "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"
@@ -43,8 +44,6 @@
     "express": "^4.18.1"
   },
   "type": "module",
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
   "types": "esm/index.d.ts",
   "exports": {
     ".": {

package/cjs/constants.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESOURCE_METADATA = exports.OpraVersion = void 0;
-exports.OpraVersion = '1.0';
-exports.RESOURCE_METADATA = 'opra:resource.metadata';

package/cjs/decorators/entity-resource.decorator.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiEntityResource = void 0;
-const tslib_1 = require("tslib");
-require("reflect-metadata");
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const constants_js_1 = require("../constants.js");
-const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
-const NAME_PATTERN = /^(.*)Resource$/;
-function ApiEntityResource(entityFunc, options) {
-    return function (target) {
-        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
-        const meta = {
-            kind: 'EntityResource',
-            type: entityFunc,
-            name
-        };
-        Object.assign(meta, lodash_1.default.omit(options, Object.keys(meta)));
-        Reflect.defineMetadata(constants_js_1.RESOURCE_METADATA, meta, target);
-        /* Define Injectable metadata for NestJS support*/
-        Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
-    };
-}
-exports.ApiEntityResource = ApiEntityResource;