@opra/common 0.25.5 → 0.26.0

package/esm/document/resource/singleton-decorator.js

@@ -0,0 +1,53 @@
+import { OpraSchema } from '../../schema/index.js';
+import { createActionDecorator } from './action-decorator.js';
+import { CollectionDecorator } from './collection-decorator.js';
+import { ResourceDecorator } from './resource-decorator.js';
+const operationProperties = ['create', 'delete', 'get', 'update'];
+export function SingletonDecorator(type, options) {
+    return ResourceDecorator(OpraSchema.Singleton.Kind, { ...options, type });
+}
+Object.assign(SingletonDecorator, ResourceDecorator);
+/*
+ * Action PropertyDecorator
+ */
+(function (SingletonDecorator) {
+    /**
+     * Action PropertyDecorator
+     */
+    function Action(options) {
+        const list = [];
+        return createActionDecorator(options, operationProperties, list);
+    }
+    SingletonDecorator.Action = Action;
+    function Create(options) {
+        return CollectionDecorator.Create(options);
+    }
+    SingletonDecorator.Create = Create;
+})(SingletonDecorator || (SingletonDecorator = {}));
+/*
+ * Get PropertyDecorator
+ */
+(function (SingletonDecorator) {
+    function Get(options) {
+        return CollectionDecorator.Get(options);
+    }
+    SingletonDecorator.Get = Get;
+})(SingletonDecorator || (SingletonDecorator = {}));
+/*
+ * Delete PropertyDecorator
+ */
+(function (SingletonDecorator) {
+    function Delete(options) {
+        return CollectionDecorator.Delete(options);
+    }
+    SingletonDecorator.Delete = Delete;
+})(SingletonDecorator || (SingletonDecorator = {}));
+/*
+ * Update PropertyDecorator
+ */
+(function (SingletonDecorator) {
+    function Update(options) {
+        return CollectionDecorator.Update(options);
+    }
+    SingletonDecorator.Update = Update;
+})(SingletonDecorator || (SingletonDecorator = {}));

package/esm/document/resource/singleton.js

@@ -1,20 +1,20 @@
 import merge from 'putil-merge';
 import { DECORATOR } from '../constants.js';
-import { SingletonDecorator } from '../decorators/singleton.decorator.js';
 import { SingletonClass } from './singleton-class.js';
+import { SingletonDecorator } from './singleton-decorator.js';
 /**
  * @class Singleton
  * @decorator Singleton
  */
 export const Singleton = function (...args) {
-    // ClassDecorator
+    // Decorator
     if (!this) {
         const [type, options] = args;
         return Singleton[DECORATOR].call(undefined, type, options);
     }
     // Constructor
-    const [document, init] = args;
-    merge(this, new SingletonClass(document, init), { descriptor: true });
+    const [parent, init] = args;
+    merge(this, new SingletonClass(parent, init), { descriptor: true });
 };
 Singleton.prototype = SingletonClass.prototype;
 Object.assign(Singleton, SingletonDecorator);

package/esm/document/resource/storage-class.js

@@ -1,20 +1,14 @@
-import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { Resource } from './resource.js';
-export class StorageClass extends Resource {
-    constructor(document, init) {
-        super(document, init);
+import { CrudResource } from './crud-resource.js';
+export class StorageClass extends CrudResource {
+    constructor(parent, init) {
+        super(parent, init);
         this.kind = OpraSchema.Storage.Kind;
-        this.controller = init.controller;
-        this.operations = { ...init.operations };
     }
-    exportSchema() {
-        return {
-            ...super.exportSchema(),
-            ...omitUndefined({
-                kind: OpraSchema.Storage.Kind,
-                operations: this.operations
-            })
-        };
+    getOperation(name) {
+        return super.getOperation(name);
+    }
+    exportSchema(options) {
+        return super.exportSchema(options);
     }
 }

package/esm/document/resource/storage-decorator.js

@@ -0,0 +1,62 @@
+import { OpraSchema } from '../../schema/index.js';
+import { createActionDecorator } from './action-decorator.js';
+import { createOperationDecorator } from './operation-decorator.js';
+import { ResourceDecorator } from './resource-decorator.js';
+const operationProperties = ['delete', 'get', 'post'];
+export function StorageDecorator(options) {
+    return ResourceDecorator(OpraSchema.Storage.Kind, options);
+}
+Object.assign(StorageDecorator, ResourceDecorator);
+/*
+ * Action PropertyDecorator
+ */
+(function (StorageDecorator) {
+    /**
+     * Action PropertyDecorator
+     */
+    function Action(options) {
+        const list = [];
+        return createActionDecorator(options, operationProperties, list);
+    }
+    StorageDecorator.Action = Action;
+    function Delete(options) {
+        const list = [];
+        return createOperationDecorator('delete', options, list);
+    }
+    StorageDecorator.Delete = Delete;
+    function Get(options) {
+        const list = [];
+        return createOperationDecorator('get', options, list);
+    }
+    StorageDecorator.Get = Get;
+    function Post(options) {
+        const list = [];
+        const decorator = createOperationDecorator('post', options, list);
+        decorator.MaxFields = (amount) => {
+            list.push(operationMeta => operationMeta.maxFields = amount);
+            return decorator;
+        };
+        decorator.MaxFieldSize = (amount) => {
+            list.push(operationMeta => operationMeta.maxFieldsSize = amount);
+            return decorator;
+        };
+        decorator.MaxFiles = (amount) => {
+            list.push(operationMeta => operationMeta.maxFiles = amount);
+            return decorator;
+        };
+        decorator.MaxFileSize = (sizeInBytes) => {
+            list.push(operationMeta => operationMeta.maxFileSize = sizeInBytes);
+            return decorator;
+        };
+        decorator.MaxTotalFileSize = (sizeInBytes) => {
+            list.push(operationMeta => operationMeta.maxTotalFileSize = sizeInBytes);
+            return decorator;
+        };
+        decorator.MinFileSize = (sizeInBytes) => {
+            list.push(operationMeta => operationMeta.minFileSize = sizeInBytes);
+            return decorator;
+        };
+        return decorator;
+    }
+    StorageDecorator.Post = Post;
+})(StorageDecorator || (StorageDecorator = {}));

package/esm/document/resource/storage.js

@@ -1,7 +1,7 @@
 import merge from 'putil-merge';
 import { DECORATOR } from '../constants.js';
-import { StorageDecorator } from '../decorators/storage.decorator.js';
 import { StorageClass } from './storage-class.js';
+import { StorageDecorator } from './storage-decorator.js';
 /**
  * @class Storage
  * @decorator Storage
@@ -13,8 +13,8 @@ export const Storage = function (...args) {
         return Storage[DECORATOR].call(undefined, options);
     }
     // Constructor
-    const [document, init] = args;
-    merge(this, new StorageClass(document, init), { descriptor: true });
+    const [parent, init] = args;
+    merge(this, new StorageClass(parent, init), { descriptor: true });
 };
 Storage.prototype = StorageClass.prototype;
 Object.assign(Storage, StorageDecorator);

package/esm/document/type-document.js

@@ -0,0 +1,191 @@
+import { NotAcceptableError, NotFoundError } from '../exception/index.js';
+import { ResponsiveMap } from '../helpers/index.js';
+import { OpraSchema } from '../schema/index.js';
+import { DATATYPE_METADATA, NAMESPACE_PATTERN } from './constants.js';
+import { ComplexType } from './data-type/complex-type.js';
+import { DocumentBase } from './document-base.js';
+export class TypeDocument extends DocumentBase {
+    constructor() {
+        super();
+        this._designCtorMap = new Map();
+        this._typeCache = new ResponsiveMap();
+        this._typesCacheByCtor = new Map();
+        this.references = new ResponsiveMap();
+        this.types = new ResponsiveMap();
+        const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+        const BufferConstructor = Object.getPrototypeOf(Buffer.from([]));
+        this._designCtorMap.set(String, 'string');
+        this._designCtorMap.set(Number, 'number');
+        this._designCtorMap.set(Boolean, 'boolean');
+        this._designCtorMap.set(Object, 'any');
+        this._designCtorMap.set(Date, 'timestamp');
+        this._designCtorMap.set(BigIntConstructor, 'bigint');
+        this._designCtorMap.set(ArrayBuffer, 'base64');
+        this._designCtorMap.set(SharedArrayBuffer, 'base64');
+        this._designCtorMap.set(BufferConstructor, 'base64');
+    }
+    /**
+     *
+     */
+    getDataType(arg0, silent) {
+        // Convert design ctor to type name (String -> 'string')
+        if (typeof arg0 === 'function') {
+            const x = this._designCtorMap.get(arg0);
+            if (x)
+                arg0 = x;
+        }
+        let dataType;
+        let name;
+        // Determine name
+        if (typeof arg0 === 'function') {
+            const metadata = Reflect.getMetadata(DATATYPE_METADATA, arg0);
+            name = metadata?.name || arg0.name;
+        }
+        else if (typeof arg0 === 'function') {
+            const metadata = Reflect.getMetadata(DATATYPE_METADATA, arg0);
+            name = metadata?.name;
+        }
+        else
+            name = String(arg0);
+        // Try to get instance from cache
+        const t = typeof arg0 === 'string'
+            ? this._typeCache.get(arg0)
+            : this._typesCacheByCtor.get(arg0);
+        if (t)
+            return t;
+        // If cached as null, it means "not found"
+        if (t === null) {
+            if (silent)
+                return;
+            throw new Error(`Data type "${name}" does not exists`);
+        }
+        if (typeof arg0 === 'string' && arg0) {
+            const m = NAMESPACE_PATTERN.exec(arg0);
+            if (!m)
+                throw new TypeError(`Invalid data type name "${name}"`);
+            // If given string has namespace pattern (ns:type_name)
+            if (m[2]) {
+                const ref = this.references.get(m[1]);
+                if (!ref) {
+                    if (silent)
+                        return;
+                    throw new Error(`No referenced document found for given namespace "${m[1]}"`);
+                }
+                dataType = ref.getDataType(m[2], silent);
+            }
+            else {
+                // Get instance from own types
+                dataType = this.types.get(arg0);
+                // if not found, search in references (from last to first)
+                if (!dataType) {
+                    const references = Array.from(this.references.values()).reverse();
+                    for (const ref of references) {
+                        dataType = ref.getDataType(name, true);
+                        if (dataType)
+                            break;
+                    }
+                }
+            }
+            if (dataType) {
+                this._typeCache.set(arg0, dataType);
+                return dataType;
+            }
+            if (!silent)
+                throw new NotFoundError(`Data type "${arg0}" does not exists`);
+            return;
+        }
+        if (typeof arg0 === 'function') {
+            const types = Array.from(this.types.values()).reverse();
+            for (const dt of types) {
+                if (dt instanceof ComplexType && dt.isTypeOf(arg0)) {
+                    dataType = dt;
+                    break;
+                }
+            }
+            // if not found, search in references (from last to first)
+            if (!dataType) {
+                const references = Array.from(this.references.values()).reverse();
+                for (const ref of references) {
+                    dataType = ref.getDataType(arg0, true);
+                    if (dataType)
+                        break;
+                }
+            }
+            if (dataType)
+                this._typesCacheByCtor.set(arg0, dataType);
+            if (dataType)
+                return dataType;
+            if (!silent)
+                throw new Error(`No data type mapping found for class "${name}"`);
+            return;
+        }
+        if (typeof arg0 === 'object') {
+            const metadata = arg0[DATATYPE_METADATA];
+            if (metadata && metadata.name) {
+                dataType = this.getDataType(metadata.name, true);
+                if (dataType)
+                    return dataType;
+                if (!silent)
+                    throw new Error(`No data type mapping found for class "${name}"`);
+            }
+        }
+        /* istanbul ignore next */
+        if (!silent)
+            throw new TypeError('Invalid argument');
+    }
+    getComplexType(nameOrCtor, silent) {
+        if (nameOrCtor === Object)
+            nameOrCtor = 'object';
+        const t = this.getDataType(nameOrCtor);
+        if (!t && silent)
+            return;
+        if (t && t.kind === OpraSchema.ComplexType.Kind)
+            return t;
+        throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+    }
+    getSimpleType(nameOrCtor, silent) {
+        const t = this.getDataType(nameOrCtor);
+        if (!t && silent)
+            return;
+        if (t && t.kind === OpraSchema.SimpleType.Kind)
+            return t;
+        throw new NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+    }
+    getEnumType(nameOrCtor, silent) {
+        const t = this.getDataType(nameOrCtor);
+        if (!t && silent)
+            return;
+        if (t && t.kind === OpraSchema.EnumType.Kind)
+            return t;
+        throw new NotAcceptableError(`Data type "${t.name || t}" is not a EnumType`);
+    }
+    /**
+     * Export as Opra schema definition object
+     */
+    exportSchema(options) {
+        const schema = super.exportSchema();
+        if (this.references.size) {
+            const references = {};
+            let i = 0;
+            for (const [ns, r] of this.references.entries()) {
+                if (ns.toLowerCase() === 'opra')
+                    continue;
+                references[ns] = r.url ? r.url : r.exportSchema(options);
+                i++;
+            }
+            if (i)
+                schema.references = references;
+        }
+        if (this.types.size) {
+            const types = schema.types = {};
+            for (const [name, r] of this.types.entries()) {
+                types[name] = r.exportSchema(options);
+            }
+        }
+        return schema;
+    }
+    invalidate() {
+        this._typeCache.clear();
+        this._typesCacheByCtor.clear();
+    }
+}

package/esm/exception/http-errors/internal-server.error.js

@@ -13,6 +13,7 @@ export class InternalServerError extends OpraException {
         super.init({
             message: translate('error:INTERNAL_SERVER_ERROR', 'Internal server error'),
             code: 'INTERNAL_SERVER_ERROR',
+            severity: 'fatal',
             ...issue
         });
     }

package/esm/exception/wrap-exception.js

@@ -1,6 +1,7 @@
 import { BadRequestError } from './http-errors/bad-request.error.js';
 import { FailedDependencyError } from './http-errors/failed-dependency.error.js';
 import { ForbiddenError } from './http-errors/forbidden.error.js';
+import { InternalServerError } from './http-errors/internal-server.error.js';
 import { MethodNotAllowedError } from './http-errors/method-not-allowed.error.js';
 import { NotAcceptableError } from './http-errors/not-acceptable.error.js';
 import { NotFoundError } from './http-errors/not-found.error.js';
@@ -33,6 +34,6 @@ export function wrapException(error) {
         case 424:
             return new FailedDependencyError(error);
         default:
-            return new FailedDependencyError(error);
+            return new InternalServerError(error);
     }
 }

package/esm/helpers/responsive-map.js

@@ -49,11 +49,11 @@ export class ResponsiveMap extends Map {
         return this;
     }
     keys() {
-        return this[kKeyOrder][Symbol.iterator]();
+        return [...this[kKeyOrder]][Symbol.iterator]();
     }
     values() {
         let i = -1;
-        const arr = this[kKeyOrder];
+        const arr = [...this[kKeyOrder]];
         const map = this;
         return {
             [Symbol.iterator]() {
@@ -70,7 +70,7 @@ export class ResponsiveMap extends Map {
     }
     entries() {
         let i = -1;
-        const arr = this[kKeyOrder];
+        const arr = [...this[kKeyOrder]];
         const map = this;
         return {
             [Symbol.iterator]() {

package/esm/http/opra-url-path.js

@@ -143,7 +143,7 @@ export class OpraURLPath {
  *
  * @class OpraURLPathComponent
  */
-class OpraURLPathComponent {
+export class OpraURLPathComponent {
     constructor(init) {
         this.resource = init.resource;
         this.key = init.key;

package/esm/schema/document/document-base.interface.js

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

package/esm/schema/document/type-document.interface.js

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

package/esm/schema/opra-schema.ns.js

@@ -12,5 +12,7 @@ export * from './resource/resource.interface.js';
 export * from './resource/singleton.interface.js';
 export * from './resource/storage.interface.js';
 export * from './constants.js';
-export * from './document.interface.js';
+export * from './document/document-base.interface.js';
+export * from './document/type-document.interface.js';
+export * from './document/api-document.interface.js';
 export * from './type-guards.js';

package/esm/schema/type-guards.js

@@ -30,7 +30,7 @@ export function isMappedType(obj) {
 export function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === EnumType.Kind;
 }
-export function isSource(obj) {
+export function isResource(obj) {
     return obj && typeof obj === 'object' &&
         (obj.kind === Container.Kind ||
             obj.kind === Collection.Kind ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "0.25.5",
+  "version": "0.26.0",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",
@@ -54,7 +54,7 @@
     "@types/encodeurl": "^1.0.0",
     "@types/validator": "^13.11.1",
     "path-browserify": "^1.0.1",
-    "ts-gems": "^2.4.1"
+    "ts-gems": "^2.5.0"
   },
   "engines": {
     "node": ">=16.0",

package/types/document/api-document.d.ts

@@ -1,99 +1,58 @@
-import { Type } from 'ts-gems';
-import { ResponsiveMap } from '../helpers/index.js';
 import { OpraSchema } from '../schema/index.js';
-import { ComplexType } from './data-type/complex-type.js';
-import type { DataType } from './data-type/data-type.js';
-import { SimpleType } from './data-type/simple-type.js';
-import { Collection } from './resource/collection.js';
-import { Resource } from './resource/resource.js';
-import { Singleton } from './resource/singleton.js';
-import { Storage } from './resource/storage.js';
-export declare class ApiDocument {
-    protected _designCtorMap: Map<Function | Type<any>, string>;
-    protected _typeCache: ResponsiveMap<DataType>;
-    protected _typesCacheByCtor: Map<object | Type<any>, DataType>;
-    protected _metadataCache?: OpraSchema.ApiDocument;
-    url?: string;
-    info: OpraSchema.DocumentInfo;
-    references: ResponsiveMap<ApiDocument>;
-    types: ResponsiveMap<DataType>;
-    resources: ResponsiveMap<Resource>;
-    constructor();
-    /**
-     * Returns DataType instance by name or Constructor. Returns undefined if not found
-     * @param nameOrCtor
-     * @param silent
-     */
-    getDataType(nameOrCtor: string | Type | object, silent: true): DataType | undefined;
-    /**
-     * Returns DataType instance by name or Constructor. Throws error  if not found
-     * @param nameOrCtor
-     */
-    getDataType(nameOrCtor: string | Type | object): DataType;
-    /**
-     * Returns ComplexType instance by name or Constructor.
-     * Returns undefined if not found
-     * Throws error if data type is not a ComplexType
-     * @param nameOrCtor
-     * @param silent
-     */
-    getComplexType(nameOrCtor: string | Type, silent: true): ComplexType | undefined;
-    /**
-     * Returns ComplexType instance by name or Constructor.
-     * Throws error undefined if not found or data type is not a ComplexType
-     * @param nameOrCtor
-     */
-    getComplexType(nameOrCtor: string | Type): ComplexType;
-    /**
-     * Returns SimpleType instance by name or Constructor.
-     * Returns undefined if not found
-     * Throws error if data type is not a SimpleType
-     * @param nameOrCtor
-     * @param silent
-     */
-    getSimpleType(nameOrCtor: string | Type, silent: true): SimpleType | undefined;
-    /**
-     Returns SimpleType instance by name or Constructor.
-     Throws error undefined if not found or data type is not a SimpleType
-     * @param nameOrCtor
-     */
-    getSimpleType(nameOrCtor: string | Type): SimpleType;
+import type { Collection } from './resource/collection.js';
+import { Container } from './resource/container.js';
+import type { Resource } from './resource/resource.js';
+import type { Singleton } from './resource/singleton.js';
+import type { Storage } from './resource/storage.js';
+import { TypeDocument } from './type-document.js';
+export declare class ApiDocument extends TypeDocument {
+    root: Container;
     /**
      * Returns Resource instance by path. Returns undefined if not found
-     * @param path
-     * @param silent
      */
-    getResource(path: string, silent: boolean): Resource | undefined;
+    getResource(path: string): Resource;
+    getResource(path: string, silent: false): Resource;
+    getResource(path: string, silent: true): Resource | undefined;
     /**
-     * Returns Resource instance by path. Throws error if not found
-     * @param path
+     * Returns Collection resource instance by path
+     * Returns undefined if not found
+     * Throws error if resource is not a Collection
      */
-    getResource(path: string): Resource;
+    getContainer(path: string): Container;
+    getContainer(path: string, silent: false): Container;
+    getContainer(path: string, silent: true): Container | undefined;
+    getContainer(path: string, silent?: boolean): Container | undefined;
     /**
      * Returns Collection resource instance by path
      * Returns undefined if not found
      * Throws error if resource is not a Collection
-     * @param path
-     * @param silent
      */
-    getCollection(path: string, silent: true): Collection | undefined;
     getCollection(path: string): Collection;
+    getCollection(path: string, silent: false): Collection;
+    getCollection(path: string, silent: true): Collection | undefined;
+    getCollection(path: string, silent?: boolean): Collection | undefined;
     /**
      * Returns Singleton resource instance by path
      * Returns undefined if not found
      * Throws error if resource is not a Collection
-     * @param path
-     * @param silent
      */
-    getSingleton(path: string, silent: true): Singleton | undefined;
     getSingleton(path: string): Singleton;
-    getStorage(path: string, silent: true): Storage | undefined;
+    getSingleton(path: string, silent: false): Singleton;
+    getSingleton(path: string, silent: true): Singleton | undefined;
+    getSingleton(path: string, silent?: boolean): Singleton | undefined;
+    /**
+     * Returns Storage resource instance by path
+     * Returns undefined if not found
+     * Throws error if resource is not a Collection
+     */
     getStorage(path: string): Storage;
+    getStorage(path: string, silent: false): Storage;
+    getStorage(path: string, silent: true): Storage | undefined;
+    getStorage(path: string, silent?: boolean): Storage | undefined;
     /**
      * Export as Opra schema definition object
      */
     exportSchema(options?: {
         webSafe?: boolean;
     }): OpraSchema.ApiDocument;
-    invalidate(): void;
 }

package/types/document/data-type/complex-type-class.d.ts

@@ -12,9 +12,7 @@ import type { UnionType } from './union-type.js';
  * @class ComplexType
  */
 export declare class ComplexTypeClass extends DataType {
-    protected _decode: vg.Validator<any, any>;
-    protected _encode: vg.Validator<any, any>;
-    readonly kind = "ComplexType";
+    readonly kind: OpraSchema.DataType.Kind;
     readonly ctor: Type;
     readonly base?: ComplexType | UnionType | MappedType;
     readonly own: ComplexType.OwnProperties;
@@ -22,12 +20,14 @@ export declare class ComplexTypeClass extends DataType {
     readonly abstract?: boolean;
     readonly additionalFields?: boolean | vg.Validator | 'error';
     constructor(document: ApiDocument, init: ComplexType.InitArguments);
-    addField(init: ApiField.InitArguments): ApiField;
     findField(nameOrPath: string): ApiField | undefined;
     getField(nameOrPath: string): ApiField;
     iteratePath(path: string, silent?: boolean): IterableIterator<[string, ApiField | undefined, string]>;
     normalizeFieldPath(fieldPaths: string | string[]): string[] | undefined;
-    exportSchema(): OpraSchema.ComplexType;
+    exportSchema(options?: {
+        webSafe?: boolean;
+    }): OpraSchema.ComplexType;
     isTypeOf(t: Type | Function): boolean;
     extendsFrom(t: string | Type | DataType): boolean;
+    generateCodec(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): vg.Validator;
 }