@opra/common 1.0.0-beta.5 → 1.0.1

package/cjs/document/http/http-controller.js

@@ -36,8 +36,6 @@ exports.HttpController = function (...args) {
     _this.ctor = initArgs.ctor;
     _this._controllerReverseMap = new WeakMap();
     _this._initialize?.(initArgs);
-    _this.onInit = initArgs.onInit;
-    _this.onShutdown = initArgs.onShutdown;
 };
 /**
  *
@@ -157,17 +155,3 @@ class HttpControllerClass extends document_element_js_1.DocumentElement {
 exports.HttpController.prototype = HttpControllerClass.prototype;
 Object.assign(exports.HttpController, http_controller_decorator_js_1.HttpControllerDecoratorFactory);
 exports.HttpController[constants_js_1.DECORATOR] = http_controller_decorator_js_1.HttpControllerDecoratorFactory;
-exports.HttpController.OnInit = function () {
-    return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target.constructor) || {});
-        sourceMetadata.onInit = target[propertyKey];
-        Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
-    };
-};
-exports.HttpController.OnShutdown = function () {
-    return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target.constructor) || {});
-        sourceMetadata.onShutdown = target[propertyKey];
-        Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
-    };
-};

package/cjs/document/rpc/rpc-controller.js

@@ -32,8 +32,6 @@ exports.RpcController = function (...args) {
     _this.ctor = initArgs.ctor;
     _this._controllerReverseMap = new WeakMap();
     _this._initialize?.(initArgs);
-    _this.onInit = initArgs.onInit;
-    _this.onShutdown = initArgs.onShutdown;
 };
 /**
  *
@@ -100,17 +98,3 @@ class RpcControllerClass extends document_element_js_1.DocumentElement {
 exports.RpcController.prototype = RpcControllerClass.prototype;
 Object.assign(exports.RpcController, rpc_controller_decorator_js_1.RpcControllerDecoratorFactory);
 exports.RpcController[constants_js_1.DECORATOR] = rpc_controller_decorator_js_1.RpcControllerDecoratorFactory;
-exports.RpcController.OnInit = function () {
-    return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(constants_js_1.RPC_CONTROLLER_METADATA, target.constructor) || {});
-        sourceMetadata.onInit = target[propertyKey];
-        Reflect.defineMetadata(constants_js_1.RPC_CONTROLLER_METADATA, target.constructor, sourceMetadata);
-    };
-};
-exports.RpcController.OnShutdown = function () {
-    return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(constants_js_1.RPC_CONTROLLER_METADATA, target.constructor) || {});
-        sourceMetadata.onShutdown = target[propertyKey];
-        Reflect.defineMetadata(constants_js_1.RPC_CONTROLLER_METADATA, target.constructor, sourceMetadata);
-    };
-};

package/cjs/filter/filter-rules.js

@@ -9,6 +9,7 @@ const parse_js_1 = require("./parse.js");
 class FilterRules {
     constructor(rules, options) {
         this._rules = new index_js_2.ResponsiveMap();
+        this._decoderCache = new WeakMap();
         Object.defineProperty(this, '_rules', {
             value: new index_js_2.ResponsiveMap(null, { caseSensitive: options?.caseSensitive }),
             enumerable: false,
@@ -28,12 +29,13 @@ class FilterRules {
             operators,
         }));
     }
-    normalizeFilter(filter, dataType) {
-        if (!filter)
-            return;
+    normalizeFilter(filter, currentType) {
         const ast = typeof filter === 'string' ? (0, parse_js_1.parse)(filter) : filter;
+        return this.normalizeFilterAst(ast, currentType);
+    }
+    normalizeFilterAst(ast, currentType, left) {
         if (ast instanceof index_js_4.ComparisonExpression) {
-            this.normalizeFilter(ast.left, dataType);
+            this.normalizeFilterAst(ast.left, currentType);
             if (!(ast.left instanceof index_js_4.QualifiedIdentifier && ast.left.field)) {
                 throw new TypeError(`Invalid filter query. Left side should be a data field.`);
             }
@@ -60,30 +62,45 @@ class FilterRules {
                     },
                 });
             }
-            this.normalizeFilter(ast.right, dataType);
+            this.normalizeFilterAst(ast.right, currentType, ast.left);
             return ast;
         }
         if (ast instanceof index_js_4.LogicalExpression) {
-            ast.items.forEach(item => this.normalizeFilter(item, dataType));
+            ast.items.forEach(item => this.normalizeFilterAst(item, currentType, left));
             return ast;
         }
         if (ast instanceof index_js_4.ArithmeticExpression) {
-            ast.items.forEach(item => this.normalizeFilter(item.expression, dataType));
+            ast.items.forEach(item => this.normalizeFilterAst(item.expression, currentType, left));
             return ast;
         }
         if (ast instanceof index_js_4.ArrayExpression) {
-            ast.items.forEach(item => this.normalizeFilter(item, dataType));
+            ast.items.forEach(item => this.normalizeFilterAst(item, currentType, left));
             return ast;
         }
         if (ast instanceof index_js_4.ParenthesizedExpression) {
-            this.normalizeFilter(ast.expression, dataType);
+            this.normalizeFilterAst(ast.expression, currentType, left);
             return ast;
         }
-        if (ast instanceof index_js_4.QualifiedIdentifier && dataType) {
-            ast.value = dataType.normalizeFieldPath(ast.value);
-            ast.field = dataType.getField(ast.value);
+        if (ast instanceof index_js_4.QualifiedIdentifier && currentType) {
+            ast.value = currentType.normalizeFieldPath(ast.value);
+            ast.field = currentType.getField(ast.value);
             ast.dataType = ast.field.type;
         }
+        if (ast instanceof index_js_4.Literal && left instanceof index_js_4.QualifiedIdentifier && left.field) {
+            if (ast.value == null && !left.field.required)
+                return ast.value;
+            let decoder = this._decoderCache.get(left.field);
+            if (!decoder) {
+                decoder = left.field.type.generateCodec('decode', {
+                    projection: '*',
+                    ignoreWriteonlyFields: true,
+                    ignoreHiddenFields: true,
+                    coerce: true,
+                });
+                this._decoderCache.set(left.field, decoder);
+            }
+            ast.value = decoder(ast.value);
+        }
         return ast;
     }
     toJSON() {

package/cjs/helpers/object-utils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cloneObject = cloneObject;
 exports.omitUndefined = omitUndefined;
 exports.omitNullish = omitNullish;
+exports.isBuiltInObject = isBuiltInObject;
 const tslib_1 = require("tslib");
 const putil_isplainobject_1 = tslib_1.__importDefault(require("putil-isplainobject"));
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
@@ -39,3 +40,18 @@ function omitNullish(obj, recursive) {
     }
     return obj;
 }
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+function isBuiltInObject(v) {
+    return (Array.isArray(v) ||
+        (typeof v === 'object' &&
+            (v instanceof Date ||
+                v instanceof RegExp ||
+                v instanceof Map ||
+                v instanceof Set ||
+                v instanceof ArrayBuffer ||
+                v instanceof SharedArrayBuffer ||
+                v instanceof Promise ||
+                v instanceof Error ||
+                v instanceof TypedArray ||
+                Buffer.isBuffer(v))));
+}

package/esm/document/http/http-controller.js

@@ -4,7 +4,7 @@ import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DataTypeMap } from '../common/data-type-map.js';
 import { DocumentElement } from '../common/document-element.js';
-import { CLASS_NAME_PATTERN, DECORATOR, HTTP_CONTROLLER_METADATA, kDataTypeMap } from '../constants.js';
+import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap } from '../constants.js';
 import { HttpControllerDecoratorFactory } from '../decorators/http-controller.decorator.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
 /**
@@ -32,8 +32,6 @@ export const HttpController = function (...args) {
     _this.ctor = initArgs.ctor;
     _this._controllerReverseMap = new WeakMap();
     _this._initialize?.(initArgs);
-    _this.onInit = initArgs.onInit;
-    _this.onShutdown = initArgs.onShutdown;
 };
 /**
  *
@@ -153,17 +151,3 @@ class HttpControllerClass extends DocumentElement {
 HttpController.prototype = HttpControllerClass.prototype;
 Object.assign(HttpController, HttpControllerDecoratorFactory);
 HttpController[DECORATOR] = HttpControllerDecoratorFactory;
-HttpController.OnInit = function () {
-    return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target.constructor) || {});
-        sourceMetadata.onInit = target[propertyKey];
-        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
-    };
-};
-HttpController.OnShutdown = function () {
-    return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target.constructor) || {});
-        sourceMetadata.onShutdown = target[propertyKey];
-        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
-    };
-};

package/esm/document/rpc/rpc-controller.js

@@ -3,7 +3,7 @@ import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DataTypeMap } from '../common/data-type-map.js';
 import { DocumentElement } from '../common/document-element.js';
-import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap, RPC_CONTROLLER_METADATA } from '../constants.js';
+import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap } from '../constants.js';
 import { RpcControllerDecoratorFactory } from '../decorators/rpc-controller.decorator.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
 /**
@@ -29,8 +29,6 @@ export const RpcController = function (...args) {
     _this.ctor = initArgs.ctor;
     _this._controllerReverseMap = new WeakMap();
     _this._initialize?.(initArgs);
-    _this.onInit = initArgs.onInit;
-    _this.onShutdown = initArgs.onShutdown;
 };
 /**
  *
@@ -97,17 +95,3 @@ class RpcControllerClass extends DocumentElement {
 RpcController.prototype = RpcControllerClass.prototype;
 Object.assign(RpcController, RpcControllerDecoratorFactory);
 RpcController[DECORATOR] = RpcControllerDecoratorFactory;
-RpcController.OnInit = function () {
-    return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(RPC_CONTROLLER_METADATA, target.constructor) || {});
-        sourceMetadata.onInit = target[propertyKey];
-        Reflect.defineMetadata(RPC_CONTROLLER_METADATA, target.constructor, sourceMetadata);
-    };
-};
-RpcController.OnShutdown = function () {
-    return (target, propertyKey) => {
-        const sourceMetadata = (Reflect.getOwnMetadata(RPC_CONTROLLER_METADATA, target.constructor) || {});
-        sourceMetadata.onShutdown = target[propertyKey];
-        Reflect.defineMetadata(RPC_CONTROLLER_METADATA, target.constructor, sourceMetadata);
-    };
-};

package/esm/filter/filter-rules.js

@@ -1,11 +1,12 @@
 import { OpraException } from '../exception/index.js';
 import { omitUndefined, ResponsiveMap } from '../helpers/index.js';
 import { translate } from '../i18n/index.js';
-import { ArithmeticExpression, ArrayExpression, ComparisonExpression, LogicalExpression, ParenthesizedExpression, QualifiedIdentifier, } from './ast/index.js';
+import { ArithmeticExpression, ArrayExpression, ComparisonExpression, Literal, LogicalExpression, ParenthesizedExpression, QualifiedIdentifier, } from './ast/index.js';
 import { parse } from './parse.js';
 export class FilterRules {
     constructor(rules, options) {
         this._rules = new ResponsiveMap();
+        this._decoderCache = new WeakMap();
         Object.defineProperty(this, '_rules', {
             value: new ResponsiveMap(null, { caseSensitive: options?.caseSensitive }),
             enumerable: false,
@@ -25,12 +26,13 @@ export class FilterRules {
             operators,
         }));
     }
-    normalizeFilter(filter, dataType) {
-        if (!filter)
-            return;
+    normalizeFilter(filter, currentType) {
         const ast = typeof filter === 'string' ? parse(filter) : filter;
+        return this.normalizeFilterAst(ast, currentType);
+    }
+    normalizeFilterAst(ast, currentType, left) {
         if (ast instanceof ComparisonExpression) {
-            this.normalizeFilter(ast.left, dataType);
+            this.normalizeFilterAst(ast.left, currentType);
             if (!(ast.left instanceof QualifiedIdentifier && ast.left.field)) {
                 throw new TypeError(`Invalid filter query. Left side should be a data field.`);
             }
@@ -57,30 +59,45 @@ export class FilterRules {
                     },
                 });
             }
-            this.normalizeFilter(ast.right, dataType);
+            this.normalizeFilterAst(ast.right, currentType, ast.left);
             return ast;
         }
         if (ast instanceof LogicalExpression) {
-            ast.items.forEach(item => this.normalizeFilter(item, dataType));
+            ast.items.forEach(item => this.normalizeFilterAst(item, currentType, left));
             return ast;
         }
         if (ast instanceof ArithmeticExpression) {
-            ast.items.forEach(item => this.normalizeFilter(item.expression, dataType));
+            ast.items.forEach(item => this.normalizeFilterAst(item.expression, currentType, left));
             return ast;
         }
         if (ast instanceof ArrayExpression) {
-            ast.items.forEach(item => this.normalizeFilter(item, dataType));
+            ast.items.forEach(item => this.normalizeFilterAst(item, currentType, left));
             return ast;
         }
         if (ast instanceof ParenthesizedExpression) {
-            this.normalizeFilter(ast.expression, dataType);
+            this.normalizeFilterAst(ast.expression, currentType, left);
             return ast;
         }
-        if (ast instanceof QualifiedIdentifier && dataType) {
-            ast.value = dataType.normalizeFieldPath(ast.value);
-            ast.field = dataType.getField(ast.value);
+        if (ast instanceof QualifiedIdentifier && currentType) {
+            ast.value = currentType.normalizeFieldPath(ast.value);
+            ast.field = currentType.getField(ast.value);
             ast.dataType = ast.field.type;
         }
+        if (ast instanceof Literal && left instanceof QualifiedIdentifier && left.field) {
+            if (ast.value == null && !left.field.required)
+                return ast.value;
+            let decoder = this._decoderCache.get(left.field);
+            if (!decoder) {
+                decoder = left.field.type.generateCodec('decode', {
+                    projection: '*',
+                    ignoreWriteonlyFields: true,
+                    ignoreHiddenFields: true,
+                    coerce: true,
+                });
+                this._decoderCache.set(left.field, decoder);
+            }
+            ast.value = decoder(ast.value);
+        }
         return ast;
     }
     toJSON() {

package/esm/helpers/object-utils.js

@@ -33,3 +33,18 @@ export function omitNullish(obj, recursive) {
     }
     return obj;
 }
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+export function isBuiltInObject(v) {
+    return (Array.isArray(v) ||
+        (typeof v === 'object' &&
+            (v instanceof Date ||
+                v instanceof RegExp ||
+                v instanceof Map ||
+                v instanceof Set ||
+                v instanceof ArrayBuffer ||
+                v instanceof SharedArrayBuffer ||
+                v instanceof Promise ||
+                v instanceof Error ||
+                v instanceof TypedArray ||
+                Buffer.isBuffer(v))));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.1",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",

package/types/document/http/http-controller.d.ts

@@ -19,8 +19,6 @@ export declare namespace HttpController {
         types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
         operations?: Record<string, HttpOperation.Metadata>;
         parameters?: HttpParameter.Metadata[];
-        onInit?: (resource: HttpController) => void;
-        onShutdown?: (resource: HttpController) => void | Promise<void>;
     }
     interface Options extends Partial<Pick<OpraSchema.HttpController, 'description' | 'path'>> {
         name?: string;
@@ -29,7 +27,7 @@ export declare namespace HttpController {
     interface InitArguments extends Combine<{
         instance?: object;
         ctor?: Type;
-    }, Pick<Metadata, 'name' | 'description' | 'path' | 'onInit' | 'onShutdown'>> {
+    }, Pick<Metadata, 'name' | 'description' | 'path'>> {
     }
 }
 /**
@@ -44,8 +42,6 @@ export interface HttpControllerStatic extends HttpControllerDecoratorFactory {
      */
     new (owner: HttpApi | HttpController, args: HttpController.InitArguments): HttpController;
     prototype: HttpController;
-    OnInit(): PropertyDecorator;
-    OnShutdown(): PropertyDecorator;
 }
 /**
  * Type definition of HttpController prototype
@@ -73,8 +69,6 @@ declare class HttpControllerClass extends DocumentElement {
     operations: ResponsiveMap<HttpOperation>;
     controllers: ResponsiveMap<HttpController>;
     types: DataTypeMap;
-    onInit?: (resource: HttpController) => void;
-    onShutdown?: (resource: HttpController) => void | Promise<void>;
     /**
      * @property isRoot
      */

package/types/document/rpc/rpc-controller.d.ts

@@ -18,8 +18,6 @@ export declare namespace RpcController {
         types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
         operations?: Record<string, RpcOperation.Metadata>;
         headers?: RpcHeader.Metadata[];
-        onInit?: (resource: RpcController) => void;
-        onShutdown?: (resource: RpcController) => void | Promise<void>;
     }
     interface Options extends Partial<Pick<OpraSchema.RpcController, 'description'>> {
         name?: string;
@@ -27,7 +25,7 @@ export declare namespace RpcController {
     interface InitArguments extends Combine<{
         instance?: object;
         ctor?: Type;
-    }, Pick<Metadata, 'name' | 'description' | 'onInit' | 'onShutdown'>> {
+    }, Pick<Metadata, 'name' | 'description'>> {
     }
 }
 /**
@@ -42,8 +40,6 @@ export interface RpcControllerStatic extends RpcControllerDecoratorFactory {
      */
     new (owner: RpcApi | RpcController, args: RpcController.InitArguments): RpcController;
     prototype: RpcController;
-    OnInit(): PropertyDecorator;
-    OnShutdown(): PropertyDecorator;
 }
 /**
  * Type definition of RpcController prototype
@@ -70,8 +66,6 @@ declare class RpcControllerClass extends DocumentElement {
     headers: RpcHeader[];
     operations: ResponsiveMap<RpcOperation>;
     types: DataTypeMap;
-    onInit?: (resource: RpcController) => void;
-    onShutdown?: (resource: RpcController) => void | Promise<void>;
     findHeader(paramName: string, location?: OpraSchema.HttpParameterLocation): RpcHeader | undefined;
     /**
      *

package/types/filter/filter-rules.d.ts

@@ -1,4 +1,5 @@
 import type { StrictOmit } from 'ts-gems';
+import { Validator } from 'valgen';
 import type { ComplexType } from '../document/index.js';
 import { ResponsiveMap } from '../helpers/index.js';
 import { OpraSchema } from '../schema/index.js';
@@ -14,11 +15,13 @@ export declare namespace FilterRules {
 }
 export declare class FilterRules {
     protected _rules: ResponsiveMap<FilterRules.Rule>;
+    protected _decoderCache: WeakMap<any, Validator<any, any, import("valgen").ExecutionOptions>>;
     constructor(rules?: Record<string, FilterRules.Rule>, options?: FilterRules.Options);
     set(fieldName: string, options?: Partial<StrictOmit<FilterRules.Rule, 'operators'>> & {
         operators?: ComparisonOperator[] | string;
     }): void;
-    normalizeFilter(filter: OpraSchema.Field.QualifiedName | Expression, dataType?: ComplexType): Expression | undefined;
+    normalizeFilter(filter: OpraSchema.Field.QualifiedName | Expression, currentType?: ComplexType): Expression | undefined;
+    protected normalizeFilterAst(ast: Expression, currentType?: ComplexType, left?: Expression): Expression | undefined;
     toJSON(): Record<string, FilterRules.Rule>;
     [Symbol.iterator](): IterableIterator<[string, FilterRules.Rule]>;
 }

package/types/helpers/object-utils.d.ts

@@ -2,3 +2,4 @@ import type { DeeperOmitTypes } from 'ts-gems';
 export declare function cloneObject<T extends {}>(obj: T, jsonOnly?: boolean): T;
 export declare function omitUndefined<T>(obj: T, recursive?: boolean): T;
 export declare function omitNullish<T>(obj: T, recursive?: boolean): DeeperOmitTypes<T, null | undefined>;
+export declare function isBuiltInObject(v: any): boolean;