@opra/common 0.21.0 → 0.23.0

package/esm/document/resource/collection.js

@@ -1,5 +1,6 @@
 import omit from 'lodash.omit';
 import merge from 'putil-merge';
+import * as vg from 'valgen';
 import { BadRequestError } from '../../exception/index.js';
 import { OpraFilter } from '../../filter/index.js';
 import { omitUndefined } from '../../helpers/index.js';
@@ -7,15 +8,18 @@ import { translate } from '../../i18n/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY } from '../constants.js';
 import { SimpleType } from '../data-type/simple-type.js';
+import { generateCodec } from '../utils/generate-codec.js';
 import { Resource } from './resource.js';
-const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__'; // todo, put this in nextjs package wia augmentation
 const NAME_PATTERN = /^(.*)(Resource|Collection)$/;
 class CollectionClass extends Resource {
     constructor(document, init) {
         super(document, init);
+        this._decoders = {};
+        this._encoders = {};
         this.kind = OpraSchema.Collection.Kind;
         this.controller = init.controller;
-        const operations = this.operations = init.operations || {};
+        this.operations = { ...init.operations };
         const dataType = this.type = init.type;
         // Validate key fields
         this.primaryKey = init.primaryKey
@@ -28,19 +32,6 @@ class CollectionClass extends Resource {
             if (!(field?.type instanceof SimpleType))
                 throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${field.type.kind}`);
         });
-        if (this.controller) {
-            const instance = typeof this.controller == 'function'
-                ? new this.controller()
-                : this.controller;
-            for (const operation of Object.values(operations)) {
-                if (!operation.handler && operation.handlerName) {
-                    const fn = instance[operation.handlerName];
-                    if (!fn)
-                        throw new TypeError(`No such operation handler (${operation.handlerName}) found`);
-                    operation.handler = fn.bind(instance);
-                }
-            }
-        }
     }
     exportSchema() {
         const out = Resource.prototype.exportSchema.call(this);
@@ -66,7 +57,8 @@ class CollectionClass extends Resource {
             // decode values
             for (const [k, v] of Object.entries(obj)) {
                 const el = dataType.getField(k);
-                obj[k] = el.type.decode(v);
+                if (el.type instanceof SimpleType)
+                    obj[k] = el.type.decode(v);
                 if (obj[k] == null)
                     throw new TypeError(`You must provide value of primary field(s) (${k})`);
             }
@@ -76,7 +68,9 @@ class CollectionClass extends Resource {
             if (typeof value === 'object')
                 value = value[primaryKey];
             const el = dataType.getField(primaryKey);
-            const result = el.type.decode(value);
+            let result;
+            if (el.type instanceof SimpleType)
+                result = el.type.decode(value);
             if (result == null)
                 throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);
             return result;
@@ -87,12 +81,14 @@ class CollectionClass extends Resource {
     }
     normalizeSortFields(fields) {
         const normalized = this.type.normalizeFieldPath(fields);
-        const findManyEndpoint = this.operations.findMany;
-        const sortFields = findManyEndpoint && findManyEndpoint.sortFields;
+        if (!normalized)
+            return;
+        const findManyOp = this.operations.findMany;
+        const sortFields = findManyOp && findManyOp.sortFields;
         (Array.isArray(normalized) ? normalized : [normalized]).forEach(field => {
             if (!sortFields?.find(x => x === field))
                 throw new BadRequestError({
-                    message: translate('error:UNACCEPTED_SORT_FIELD', { field }, `Field '${field}' is not available for sort operation`),
+                    message: translate('error:UNACCEPTED_SORT_FIELD', { field }),
                 });
         });
         return normalized;
@@ -105,27 +101,75 @@ class CollectionClass extends Resource {
             this.normalizeFilter(ast.left);
             if (!(ast.left instanceof OpraFilter.QualifiedIdentifier && ast.left.field))
                 throw new TypeError(`Invalid filter query. Left side should be a data field.`);
+            // Check if filtering accepted for given field
+            const findManyOp = this.operations.findMany;
+            const fieldLower = ast.left.value.toLowerCase();
+            const filterDef = (findManyOp && findManyOp.filters || [])
+                .find(f => f.field.toLowerCase() === fieldLower);
+            if (!filterDef) {
+                throw new BadRequestError({
+                    message: translate('error:UNACCEPTED_FILTER_FIELD', { field: ast.left.value }),
+                });
+            }
+            // Check if filtering operation accepted for given field
+            if (!filterDef.operators?.includes(ast.op))
+                throw new BadRequestError({
+                    message: translate('error:UNACCEPTED_FILTER_OPERATION', { field: ast.left.value }),
+                });
             this.normalizeFilter(ast.right);
+            return ast;
         }
-        else if (ast instanceof OpraFilter.LogicalExpression) {
+        if (ast instanceof OpraFilter.LogicalExpression) {
             ast.items.forEach(item => this.normalizeFilter(item));
+            return ast;
         }
-        else if (ast instanceof OpraFilter.ArithmeticExpression) {
+        if (ast instanceof OpraFilter.ArithmeticExpression) {
             ast.items.forEach(item => this.normalizeFilter(item.expression));
+            return ast;
         }
-        else if (ast instanceof OpraFilter.ArrayExpression) {
+        if (ast instanceof OpraFilter.ArrayExpression) {
             ast.items.forEach(item => this.normalizeFilter(item));
+            return ast;
         }
-        else if (ast instanceof OpraFilter.ParenthesizedExpression) {
+        if (ast instanceof OpraFilter.ParenthesizedExpression) {
             this.normalizeFilter(ast.expression);
+            return ast;
         }
-        else if (ast instanceof OpraFilter.QualifiedIdentifier) {
-            ast.field = this.type.findField(ast.value);
+        if (ast instanceof OpraFilter.QualifiedIdentifier) {
+            const normalizedFieldPath = this.type.normalizeFieldPath(ast.value)?.join('.');
+            ast.field = this.type.getField(normalizedFieldPath);
             ast.dataType = ast.field?.type || this.document.getDataType('any');
-            ast.value = this.type.normalizeFieldPath(ast.value);
+            ast.value = normalizedFieldPath;
+            return ast;
         }
         return ast;
     }
+    getDecoder(operation) {
+        let decoder = this._decoders[operation];
+        if (decoder)
+            return decoder;
+        const options = {
+            partial: operation !== 'create'
+        };
+        if (operation !== 'create')
+            options.omit = [...this.primaryKey];
+        decoder = generateCodec(this.type, 'decode', options);
+        this._decoders[operation] = decoder;
+        return decoder;
+    }
+    getEncoder(operation) {
+        let encoder = this._encoders[operation];
+        if (encoder)
+            return encoder;
+        const options = {
+            partial: true
+        };
+        encoder = generateCodec(this.type, 'encode', options);
+        if (operation === 'findMany')
+            return vg.isArray(encoder);
+        this._encoders[operation] = encoder;
+        return encoder;
+    }
 }
 /**
  *
@@ -163,13 +207,12 @@ export const Collection = function (...args) {
 Collection.prototype = CollectionClass.prototype;
 function createOperationDecorator(operation) {
     return (options) => ((target, propertyKey) => {
-        const metadata = {
-            ...options,
-            handlerName: propertyKey
-        };
+        if (propertyKey !== operation)
+            throw new TypeError(`Name of the handler name should be '${operation}'`);
+        const operationMeta = { ...options };
         const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
         resourceMetadata.operations = resourceMetadata.operations || {};
-        resourceMetadata.operations[operation] = metadata;
+        resourceMetadata.operations[operation] = operationMeta;
         Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
     });
 }

package/esm/document/resource/singleton.js

@@ -3,29 +3,19 @@ import merge from 'putil-merge';
 import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY } from '../constants.js';
+import { generateCodec } from '../utils/generate-codec.js';
 import { Resource } from './resource.js';
-const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__'; // todo, put this in nextjs package wia augmentation
 const NAME_PATTERN = /^(.*)(Resource|Singleton)$/;
 class SingletonClass extends Resource {
     constructor(document, init) {
         super(document, init);
+        this._decoders = {};
+        this._encoders = {};
         this.kind = OpraSchema.Singleton.Kind;
         this.controller = init.controller;
-        const operations = this.operations = init.operations || {};
+        this.operations = { ...init.operations };
         this.type = init.type;
-        if (this.controller) {
-            const instance = typeof this.controller == 'function'
-                ? new this.controller()
-                : this.controller;
-            for (const operation of Object.values(operations)) {
-                if (!operation.handler && operation.handlerName) {
-                    const fn = instance[operation.handlerName];
-                    if (!fn)
-                        throw new TypeError(`No such operation handler (${operation.handlerName}) found`);
-                    operation.handler = fn.bind(instance);
-                }
-            }
-        }
     }
     exportSchema() {
         const out = Resource.prototype.exportSchema.call(this);
@@ -38,6 +28,28 @@ class SingletonClass extends Resource {
     normalizeFieldPath(path) {
         return this.type.normalizeFieldPath(path);
     }
+    getDecoder(operation) {
+        let decoder = this._decoders[operation];
+        if (decoder)
+            return decoder;
+        const options = {
+            partial: operation !== 'create'
+        };
+        decoder = generateCodec(this.type, 'decode', options);
+        this._decoders[operation] = decoder;
+        return decoder;
+    }
+    getEncoder(operation) {
+        let encoder = this._encoders[operation];
+        if (encoder)
+            return encoder;
+        const options = {
+            partial: true
+        };
+        encoder = generateCodec(this.type, 'encode', options);
+        this._encoders[operation] = encoder;
+        return encoder;
+    }
 }
 export const Singleton = function (...args) {
     // ClassDecorator
@@ -68,13 +80,12 @@ export const Singleton = function (...args) {
 Singleton.prototype = SingletonClass.prototype;
 function createOperationDecorator(operation) {
     return (options) => ((target, propertyKey) => {
-        const metadata = {
-            ...options,
-            handlerName: propertyKey
-        };
+        if (propertyKey !== operation)
+            throw new TypeError(`Name of the handler name should be '${operation}'`);
+        const operationMeta = { ...options };
         const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
         resourceMetadata.operations = resourceMetadata.operations || {};
-        resourceMetadata.operations[operation] = metadata;
+        resourceMetadata.operations[operation] = operationMeta;
         Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
     });
 }

package/esm/document/resource/storage.js

@@ -11,20 +11,7 @@ class StorageClass extends Resource {
         super(document, init);
         this.kind = OpraSchema.Storage.Kind;
         this.controller = init.controller;
-        const operations = this.operations = init.operations || {};
-        if (this.controller) {
-            const instance = typeof this.controller == 'function'
-                ? new this.controller()
-                : this.controller;
-            for (const operation of Object.values(operations)) {
-                if (!operation.handler && operation.handlerName) {
-                    const fn = instance[operation.handlerName];
-                    if (!fn)
-                        throw new TypeError(`No such operation handler (${operation.handlerName}) found`);
-                    operation.handler = fn.bind(instance);
-                }
-            }
-        }
+        this.operations = { ...init.operations };
     }
     exportSchema() {
         const out = Resource.prototype.exportSchema.call(this);
@@ -62,16 +49,15 @@ export const Storage = function (...args) {
 Storage.prototype = StorageClass.prototype;
 function createOperationDecorator(operation) {
     return (options) => ((target, propertyKey) => {
-        const metadata = {
-            ...options,
-            handlerName: propertyKey
-        };
+        if (propertyKey !== operation)
+            throw new TypeError(`Name of the handler name should be '${operation}'`);
+        const operationMeta = { ...options };
         const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
         resourceMetadata.operations = resourceMetadata.operations || {};
-        resourceMetadata.operations[operation] = metadata;
+        resourceMetadata.operations[operation] = operationMeta;
         Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
     });
 }
 Storage.Delete = createOperationDecorator('delete');
 Storage.Get = createOperationDecorator('get');
-Storage.Put = createOperationDecorator('put');
+Storage.Post = createOperationDecorator('post');

package/esm/document/utils/generate-codec.js

@@ -0,0 +1,33 @@
+import * as vg from 'valgen';
+import { ComplexType } from '../data-type/complex-type.js';
+import { EnumType } from '../data-type/enum-type.js';
+import { MappedType } from '../data-type/mapped-type.js';
+import { SimpleType } from '../data-type/simple-type.js';
+import { UnionType } from '../data-type/union-type.js';
+export function generateCodec(type, codec, options) {
+    return _generateDecoder(type, codec, options);
+}
+export function _generateDecoder(type, codec, options) {
+    const schema = {};
+    for (const f of type.fields.values()) {
+        let fn;
+        if (f.type instanceof SimpleType || f.type instanceof EnumType) {
+            fn = f.type[codec];
+        }
+        else if (f.type instanceof ComplexType || f.type instanceof MappedType || f.type instanceof UnionType) {
+            fn = _generateDecoder(f.type, codec, options);
+        }
+        /* istanbul ignore next */
+        if (!fn)
+            throw new TypeError(`Can't generate codec for (${f.type})`);
+        if (f.isArray)
+            fn = vg.isArray(fn);
+        schema[f.name] = !options.partial && f.required ? vg.required(fn) : vg.optional(fn);
+    }
+    return vg.isObject(schema, {
+        ctor: type.ctor,
+        additionalFields: type.additionalFields ?? 'ignore',
+        name: type.name,
+        caseInSensitive: true,
+    });
+}

package/esm/exception/resource-errors/resource-not-found.error.js

@@ -7,7 +7,7 @@ import { OpraException } from '../opra-exception.js';
 export class ResourceNotFoundError extends OpraException {
     constructor(resource, keyValue, cause) {
         super({
-            message: translate(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? '@' + keyValue : '') }, `The resource '{{resource}}' could not be found`),
+            message: translate(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? '@' + keyValue : '') }, `The resource '{{resource}}' not found`),
             severity: 'error',
             code: 'RESOURCE_NOT_FOUND',
             details: {

package/esm/helpers/index.js

@@ -1,6 +1,6 @@
 export * from './function-utils.js';
 export * from './get-stack-filename.js';
-export * from './is-url.js';
+export * from './is-url-string.js';
 export * from './mixin-utils.js';
 export * from './object-utils.js';
 export * from './path-to-object-tree.js';

package/esm/helpers/is-url-string.js

@@ -0,0 +1,9 @@
+import { URL } from 'url';
+const URL_PATTERN = /^(https?:\/\/.)[-a-zA-Z0-9@:%._+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_+.~#?&/=]*)$/i;
+export function isUrlString(url) {
+    return URL_PATTERN.test(url);
+}
+export const isAbsoluteUrl = (urlString) => {
+    return !urlString.includes('://') &&
+        (new URL(urlString, 'http://tempuri.org/')).host !== 'tempuri.org';
+};

package/esm/helpers/object-utils.js

@@ -12,13 +12,13 @@ export function cloneObject(obj, jsonOnly) {
         }
     });
 }
-export function omitUndefined(obj) {
+export function omitUndefined(obj, recursive) {
     if (!(obj && typeof obj === 'object'))
         return obj;
     for (const k of Object.keys(obj)) {
         if (obj[k] === undefined)
             delete obj[k];
-        else if (typeof obj[k] === 'object')
+        else if (recursive && typeof obj[k] === 'object')
             omitUndefined(obj[k]);
     }
     return obj;

package/esm/helpers/responsive-map.js

@@ -2,10 +2,10 @@ var _a, _b, _c, _d;
 function isMap(v) {
     return v && typeof v.forEach === 'function';
 }
-const kKeyMap = Symbol('kKeyMap');
-const kKeyOrder = Symbol('kKeyOrder');
-const kWellKnownKeys = Symbol('kWellKnownKeys');
-const kOptions = Symbol('kOptions');
+const kKeyMap = Symbol.for('kKeyMap');
+const kKeyOrder = Symbol.for('kKeyOrder');
+const kWellKnownKeys = Symbol.for('kWellKnownKeys');
+const kOptions = Symbol.for('kOptions');
 /**
  * A Map implementation that supports case-insensitivity and ordered keys
  */

package/esm/helpers/type-guards.js

@@ -11,13 +11,15 @@ export function isStream(stream) {
 }
 export function isReadable(x) {
     return isStream(x)
-        && x.readable !== false
         && typeof x._read === 'function'
         && typeof x._readableState === 'object';
 }
+export function isWritable(x) {
+    return isStream(x)
+        && typeof x._write === 'function';
+}
 export function isReadableStream(x) {
     return isStream(x)
-        && x.readable !== false
         && typeof x.getReader === 'function'
         && typeof x.pipeThrough === 'function'
         && typeof x.pipeTo === 'function';
@@ -38,6 +40,13 @@ export function isFormData(x) {
 }
 export function isURL(x) {
     return x !== null
+        && typeof x == 'object'
         && typeof x.host === 'string'
         && typeof x.href === 'string';
 }
+export function isIterable(x) {
+    return Symbol.iterator in x;
+}
+export function isAsyncIterable(x) {
+    return Symbol.asyncIterator in x;
+}

package/esm/http/enums/http-headers-codes.enum.js

@@ -4,11 +4,9 @@
  */
 export var HttpHeaderCodes;
 (function (HttpHeaderCodes) {
-    /* *** Opra Headers *** */
-    HttpHeaderCodes["X_Opra_Version"] = "X-OPRA-Version";
-    HttpHeaderCodes["X_Opra_Data_Type"] = "X-OPRA-Data-Type";
-    HttpHeaderCodes["X_Opra_Operation"] = "X-OPRA-Operation";
-    HttpHeaderCodes["X_Opra_Total_Matches"] = "X-OPRA-Total-Matches";
+    /* *** Opra Custom Headers *** */
+    HttpHeaderCodes["X_Opra_Version"] = "X-Opra-Version";
+    HttpHeaderCodes["X_Total_Count"] = "X-Total-Count";
     /* *** Authentication *** */
     /**
      * Defines the authentication method that should be used to access a resource.

package/esm/http/enums/http-status-codes.enum.js

@@ -225,7 +225,7 @@ export var HttpStatusCodes;
      * to do so after the client upgrades to a different protocol. The server sends an Upgrade
      * header in a 426 response to indicate the required protocol(s).
      */
-    HttpStatusCodes[HttpStatusCodes["UPGRADE_REQUIRED"] = 428] = "UPGRADE_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
     /**
      * The origin server requires the request to be conditional. This response is intended to prevent
      * the 'lost update' problem, where a client GETs a resource's state, modifies it and PUTs

package/esm/http/index.js

@@ -1,12 +1,5 @@
-export * from './http-params.js';
+export * from './opra-url.js';
+export * from './opra-url-path.js';
 export * from './enums/http-headers-codes.enum.js';
 export * from './enums/http-status-codes.enum.js';
 export * from './enums/http-status-messages.js';
-export * from './interfaces/client-http-headers.interface.js';
-export * from './interfaces/server-http-headers.interface.js';
-export * from './codecs/date-codec.js';
-export * from './codecs/boolean-codec.js';
-export * from './codecs/filter-codec.js';
-export * from './codecs/integer-codec.js';
-export * from './codecs/number-codec.js';
-export * from './codecs/string-codec.js';