@opra/common 0.33.13 → 1.0.0-alpha.2

package/esm/schema/type-guards.js

@@ -3,17 +3,15 @@ import { EnumType } from './data-type/enum-type.interface.js';
 import { MappedType } from './data-type/mapped-type.interface.js';
 import { MixinType } from './data-type/mixin-type.interface.js';
 import { SimpleType } from './data-type/simple-type.interface.js';
-import { Collection } from './resource/collection.interface.js';
-import { Container } from './resource/container.interface.js';
-import { Singleton } from './resource/singleton.interface.js';
-import { Storage } from './resource/storage.interface.js';
+import { HttpController } from './http/http-controller.interface.js';
 export function isDataType(obj) {
-    return obj && typeof obj === 'object' &&
+    return (obj &&
+        typeof obj === 'object' &&
         (obj.kind === ComplexType.Kind ||
             obj.kind === EnumType.Kind ||
             obj.kind === MappedType.Kind ||
             obj.kind === SimpleType.Kind ||
-            obj.kind === MixinType.Kind);
+            obj.kind === MixinType.Kind));
 }
 export function isComplexType(obj) {
     return obj && typeof obj === 'object' && obj.kind === ComplexType.Kind;
@@ -30,22 +28,6 @@ export function isMappedType(obj) {
 export function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === EnumType.Kind;
 }
-export function isResource(obj) {
-    return obj && typeof obj === 'object' &&
-        (obj.kind === Container.Kind ||
-            obj.kind === Collection.Kind ||
-            obj.kind === Singleton.Kind ||
-            obj.kind === Storage.Kind);
-}
-export function isCollection(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Collection.Kind;
-}
-export function isSingleton(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Singleton.Kind;
-}
-export function isStorage(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Storage.Kind;
-}
-export function isContainer(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Container.Kind;
+export function isHttpController(obj) {
+    return obj && typeof obj === 'object' && obj.kind === HttpController.Kind;
 }

package/esm/schema/value.interface.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "0.33.13",
+  "version": "1.0.0-alpha.2",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",
@@ -24,6 +24,7 @@
     "postbuild": "cp package.json ../../LICENSE ../../build/common && cp ../../package.cjs.json ../../build/common/cjs/package.json",
     "lint": "eslint . --max-warnings=0",
     "check": "madge --circular src/**",
+    "format": "prettier . --write --log-level=warn",
     "test": "jest",
     "cover": "jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
@@ -34,29 +35,29 @@
     "antlr4": "java -jar ./tools/antlr4-4.12.1-SNAPSHOT-complete.jar -Dlanguage=TypeScript ./src/filter/antlr/OpraFilter.g4 -visitor"
   },
   "dependencies": {
-    "@browsery/antlr4": "^0.9.0",
-    "@browsery/highland": "^0.6.0",
-    "@browsery/http-parser": "^0.4.0",
-    "@browsery/i18next": "^0.7.2",
-    "fast-tokenizer": "^1.2.2",
+    "@browsery/antlr4": "^4.13.1",
+    "@browsery/highland": "^2.13.5",
+    "@browsery/http-parser": "^0.5.8",
+    "@browsery/i18next": "^23.8.2",
+    "fast-tokenizer": "^1.3.0",
     "lodash.omit": "^4.5.0",
     "putil-isplainobject": "^1.1.5",
     "putil-merge": "^3.12.1",
     "putil-promisify": "^1.10.1",
     "putil-varhelpers": "^1.6.5",
-    "reflect-metadata": "^0.1.14",
+    "reflect-metadata": "^0.2.2",
     "uid": "^2.0.1",
-    "valgen": "^5.2.0"
+    "valgen": "^5.4.1"
   },
   "devDependencies": {
     "@browsery/fs": "^0.4.0",
-    "@browsery/stream": "^0.6.0",
-    "@browsery/util": "^0.4.0",
+    "@browsery/stream": "^4.3.0",
+    "@browsery/util": "^0.12.5",
     "@types/encodeurl": "^1.0.2",
     "@types/lodash.omit": "^4.5.9",
-    "@types/validator": "^13.11.8",
+    "@types/validator": "^13.11.10",
     "path-browserify": "^1.0.1",
-    "ts-gems": "^3.1.1"
+    "ts-gems": "^3.4.0"
   },
   "engines": {
     "node": ">=16.0",
@@ -76,4 +77,4 @@
     "opra",
     "common"
   ]
-}
+}

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

@@ -1,58 +1,38 @@
+import { Type } from 'ts-gems';
+import { ResponsiveMap } from '../helpers/index.js';
 import { OpraSchema } from '../schema/index.js';
-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
-     */
-    getResource(path: string): Resource;
-    getResource(path: string, silent: false): Resource;
-    getResource(path: string, silent: true): Resource | undefined;
-    /**
-     * Returns Collection resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    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
-     */
-    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
-     */
-    getSingleton(path: string): Singleton;
-    getSingleton(path: string, silent: false): Singleton;
-    getSingleton(path: string, silent: true): Singleton | undefined;
-    getSingleton(path: string, silent?: boolean): Singleton | undefined;
+import { DataTypeMap } from './common/data-type-map.js';
+import { DocumentElement } from './common/document-element.js';
+import { kTypeNSMap } from './constants.js';
+import { DataType } from './data-type/data-type.js';
+import type { EnumType } from './data-type/enum-type.js';
+import type { HttpApi } from './http/http-api.js';
+export declare namespace ApiDocument {
+    interface ExportOptions {
+        references?: 'inline' | 'relative-url' | 'external-url';
+    }
+}
+/**
+ *
+ * @class ApiDocument
+ */
+export declare class ApiDocument extends DocumentElement {
+    protected [kTypeNSMap]: WeakMap<DataType, string>;
+    url?: string;
+    info: OpraSchema.DocumentInfo;
+    references: ResponsiveMap<ApiDocument>;
+    types: DataTypeMap;
+    api?: HttpApi;
+    constructor();
     /**
-     * Returns Storage resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
+     * Returns NS of datatype. Returns undefined if not found
+     * @param nameOrCtor
      */
-    getStorage(path: string): Storage;
-    getStorage(path: string, silent: false): Storage;
-    getStorage(path: string, silent: true): Storage | undefined;
-    getStorage(path: string, silent?: boolean): Storage | undefined;
+    getDataTypeNs(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject | DataType): string | undefined;
+    toJSON(): OpraSchema.ApiDocument;
     /**
      * Export as Opra schema definition object
      */
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.ApiDocument;
+    export(options?: ApiDocument.ExportOptions): OpraSchema.ApiDocument;
+    protected _findDataType(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject, visitedRefs?: WeakMap<ApiDocument, boolean>): DataType | undefined;
 }

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

@@ -0,0 +1,17 @@
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
+import { DocumentElement } from './document-element.js';
+import type { DocumentInitContext } from './document-init-context';
+export declare namespace ApiBase {
+    interface InitArguments extends Pick<OpraSchema.Api, 'description' | 'name'> {
+    }
+}
+export declare abstract class ApiBase extends DocumentElement {
+    readonly owner: ApiDocument | ApiBase;
+    abstract readonly protocol: OpraSchema.Protocol;
+    name: string;
+    description?: string;
+    protected constructor(owner: ApiDocument | ApiBase);
+    toJSON(): OpraSchema.Api;
+    protected _initialize(init: ApiBase.InitArguments, context: DocumentInitContext): Promise<void>;
+}

package/types/document/common/data-type-map.d.ts

@@ -0,0 +1,23 @@
+import { Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { DataType } from '../data-type/data-type.js';
+declare const kMap: unique symbol;
+declare const kCtorMap: unique symbol;
+/**
+ * @class DataTypeMap
+ */
+export declare class DataTypeMap {
+    protected [kMap]: ResponsiveMap<DataType>;
+    protected [kCtorMap]: WeakMap<object | Function | Type<any>, string>;
+    get size(): number;
+    forEach(callbackFn: (value: DataType, key: string, map: ReadonlyMap<string, DataType>) => void, thisArg?: any): void;
+    get(nameOrCtor: string | Type | Function | object): DataType | undefined;
+    set(name: string, dataType: DataType): void;
+    has(nameOrCtor: string | Type | Function | object | DataType): boolean;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<DataType>;
+    entries(): IterableIterator<[string, DataType]>;
+    sort(compareFn?: (a: string, b: string) => number): this;
+    [Symbol.iterator](): IterableIterator<[string, DataType]>;
+}
+export {};

package/types/document/common/document-element.d.ts

@@ -0,0 +1,23 @@
+import { DocumentNode } from './document-node.js';
+interface DocumentElementConstructor {
+    new (owner?: DocumentElement): DocumentElement;
+    prototype: DocumentElement;
+}
+/**
+ * @class DocumentElement
+ */
+export interface DocumentElement extends DocumentElementClass {
+}
+/**
+ *
+ * @constructor DocumentElement
+ */
+export declare const DocumentElement: DocumentElementConstructor;
+/**
+ * @class DocumentElement
+ */
+declare abstract class DocumentElementClass {
+    readonly owner?: DocumentElement;
+    readonly node: DocumentNode;
+}
+export {};

package/types/document/common/document-init-context.d.ts

@@ -0,0 +1,17 @@
+import { OpraDocumentError } from './opra-document-error.js';
+export declare namespace DocumentInitContext {
+    interface Options {
+        maxErrors?: number;
+    }
+}
+export declare class DocumentInitContext {
+    path: string;
+    error: OpraDocumentError;
+    maxErrors: number;
+    showErrorDetails: boolean;
+    constructor(options?: DocumentInitContext.Options);
+    addError(error: Error | OpraDocumentError.ErrorDetail | string): void;
+    enter(path: string, fn: () => any): any;
+    enterAsync(path: string, fn: () => any): Promise<any>;
+    extend<T>(args: T): this & T;
+}

package/types/document/common/document-node.d.ts

@@ -0,0 +1,65 @@
+import { Type } from 'ts-gems';
+import type { ApiDocument } from '../api-document.js';
+import { kDataTypeMap } from '../constants.js';
+import type { ComplexType } from '../data-type/complex-type';
+import type { DataType } from '../data-type/data-type';
+import type { EnumType } from '../data-type/enum-type';
+import type { MappedType } from '../data-type/mapped-type';
+import type { MixinType } from '../data-type/mixin-type';
+import type { SimpleType } from '../data-type/simple-type';
+import type { DataTypeMap } from './data-type-map.js';
+import type { DocumentElement } from './document-element';
+/**
+ * @class DocumentNode
+ */
+export declare class DocumentNode {
+    protected [kDataTypeMap]?: DataTypeMap;
+    protected _document?: ApiDocument;
+    readonly parent?: DocumentNode;
+    readonly element: DocumentElement;
+    constructor(element: DocumentElement, parent?: DocumentNode);
+    getDocument(): ApiDocument;
+    hasDataType(nameOrCtor: string | Type | Function | object | any[]): boolean;
+    findDataType(nameOrCtor: string | Type | Function | object | any[]): DataType | undefined;
+    /**
+     * Returns DataType instance by name or Constructor. Returns undefined if not found
+     * @param nameOrCtor
+     */
+    getDataType(nameOrCtor: string | Type | Function | object | any[]): DataType;
+    getDataTypeNameWithNs(dataType: DataType): string | undefined;
+    /**
+     * Returns ComplexType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a ComplexType
+     * @param nameOrCtor
+     */
+    getComplexType(nameOrCtor: string | Type | Function): ComplexType;
+    /**
+     * Returns SimpleType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a SimpleType
+     * @param nameOrCtor
+     */
+    getSimpleType(nameOrCtor: string | Type): SimpleType;
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a EnumType
+     * @param nameOrCtor
+     */
+    getEnumType(nameOrCtor: string | object | any[]): EnumType;
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a MappedType
+     * @param nameOrCtor
+     */
+    getMappedType(nameOrCtor: string | object | any[]): MappedType;
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a MixinType
+     * @param nameOrCtor
+     */
+    getMixinType(nameOrCtor: string | object | any[]): MixinType;
+}

package/types/document/common/opra-document-error.d.ts

@@ -0,0 +1,12 @@
+import { OpraException } from '../../exception/opra-exception.js';
+export declare namespace OpraDocumentError {
+    interface ErrorDetail {
+        message: string;
+        path: string;
+    }
+}
+export declare class OpraDocumentError extends OpraException {
+    details: OpraDocumentError.ErrorDetail[];
+    constructor();
+    add(detail: OpraDocumentError.ErrorDetail): this;
+}

package/types/document/common/value.d.ts

@@ -0,0 +1,48 @@
+import { Combine, StrictOmit, TypeThunkAsync } from 'ts-gems';
+import type { OpraSchema } from '../../schema/index.js';
+import { DataType } from '../data-type/data-type.js';
+import type { EnumType } from '../data-type/enum-type.js';
+import { DocumentElement } from './document-element.js';
+/**
+ * @namespace Value
+ */
+export declare namespace Value {
+    interface Metadata extends StrictOmit<OpraSchema.Value, 'type'> {
+        type?: string | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
+    }
+    interface Options extends Partial<StrictOmit<Metadata, 'type'>> {
+        type?: string | TypeThunkAsync | object;
+    }
+    interface InitArguments extends Combine<{
+        type?: DataType;
+    }, Metadata> {
+    }
+}
+/**
+ * Type definition for Value
+ * @class Value
+ */
+interface ValueStatic {
+    new (owner: DocumentElement, args: Value.InitArguments): Value;
+    prototype: Value;
+}
+/**
+ * Type definition of Value prototype
+ * @interface Value
+ */
+export interface Value extends ValueClass {
+}
+export declare const Value: ValueStatic;
+/**
+ * @class Value
+ */
+declare class ValueClass extends DocumentElement {
+    readonly owner: DocumentElement;
+    readonly name: string | RegExp;
+    type?: DataType;
+    description?: string;
+    examples?: any[] | Record<string, any>;
+    isArray?: boolean;
+    toJSON(): OpraSchema.Value;
+}
+export {};

package/types/document/constants.d.ts

@@ -1,6 +1,12 @@
 export declare const DATATYPE_METADATA: unique symbol;
-export declare const RESOURCE_METADATA: unique symbol;
+export declare const HTTP_CONTROLLER_METADATA: unique symbol;
+export declare const DECODER: unique symbol;
+export declare const ENCODER: unique symbol;
 export declare const DECORATOR: unique symbol;
+export declare const BUILTIN: unique symbol;
 export declare const NAMESPACE_PATTERN: RegExp;
-export declare const TYPENAME_PATTERN: RegExp;
-export declare const SORT_FIELD_PATTERN: RegExp;
+export declare const CLASS_NAME_PATTERN: RegExp;
+export declare const EXTRACT_TYPENAME_PATTERN: RegExp;
+export declare const kDataTypeMap: unique symbol;
+export declare const kCtorMap: unique symbol;
+export declare const kTypeNSMap: unique symbol;

package/types/document/data-type/api-field.d.ts

@@ -0,0 +1,65 @@
+import { Combine, TypeThunkAsync } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { ApiFieldDecorator } from '../decorators/api-field-decorator.js';
+import type { ComplexType } from './complex-type.js';
+import type { DataType } from './data-type.js';
+import type { EnumType } from './enum-type.js';
+import type { MappedType } from './mapped-type.js';
+import type { MixinType } from './mixin-type.js';
+/**
+ * @namespace ApiField
+ */
+export declare namespace ApiField {
+    interface Metadata extends Combine<{
+        type?: string | OpraSchema.DataType | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
+    }, OpraSchema.Field> {
+    }
+    interface Options extends Partial<Metadata> {
+    }
+    interface InitArguments extends Combine<{
+        name: string;
+        origin?: ComplexType | MappedType | MixinType;
+        type?: DataType;
+    }, Metadata> {
+    }
+}
+/**
+ * Type definition of ComplexType constructor type
+ * @type ApiFieldConstructor
+ */
+export interface ApiFieldConstructor extends ApiFieldDecorator {
+    prototype: ApiField;
+    new (owner: ComplexType | MappedType | MixinType, args: ApiField.InitArguments): ApiField;
+}
+/**
+ * @class ApiField
+ */
+export interface ApiField extends ApiFieldClass {
+}
+/**
+ * @constructor ApiField
+ * @decorator ApiField
+ */
+export declare const ApiField: ApiFieldConstructor;
+/**
+ *
+ * @class ApiField
+ */
+declare class ApiFieldClass extends DocumentElement {
+    readonly owner: ComplexType | MappedType | MixinType;
+    readonly origin?: ComplexType | MappedType | MixinType;
+    readonly name: string;
+    readonly type: DataType;
+    readonly description?: string;
+    readonly isArray?: boolean;
+    readonly default?: any;
+    readonly fixed?: any;
+    readonly required?: boolean;
+    readonly exclusive?: boolean;
+    readonly translatable?: boolean;
+    readonly deprecated?: boolean | string;
+    readonly examples?: any[] | Record<string, any>;
+    toJSON(): OpraSchema.Field;
+}
+export {};

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

@@ -0,0 +1,80 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { IsObject, Validator } from 'valgen';
+import { FieldsProjection, ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { DocumentElement } from '../common/document-element.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import type { ApiField } from './api-field';
+import type { ComplexType } from './complex-type';
+import { DataType } from './data-type.js';
+import Field = OpraSchema.Field;
+export declare const FIELD_PATH_PATTERN: RegExp;
+/**
+ * Type definition of class constructor for ComplexTypeBase
+ * @class ComplexTypeBase
+ */
+interface ComplexTypeBaseStatic {
+    /**
+     * Class constructor of MappedType
+     *
+     * @param owner
+     * @param initArgs
+     * @param context
+     * @constructor
+     */
+    new (owner: DocumentElement, initArgs: DataType.InitArguments, context?: DocumentInitContext): ComplexTypeBase;
+    prototype: ComplexTypeBase;
+}
+/**
+ * Type definition of ComplexTypeBase prototype
+ * @interface ComplexTypeBase
+ */
+export interface ComplexTypeBase extends ComplexTypeBaseClass {
+}
+/**
+ *
+ * @constructor
+ */
+export declare const ComplexTypeBase: ComplexTypeBaseStatic;
+/**
+ *
+ */
+declare abstract class ComplexTypeBaseClass extends DataType {
+    readonly ctor?: Type;
+    readonly fields: ResponsiveMap<ApiField>;
+    readonly additionalFields?: boolean | DataType | ['error'] | ['error', string];
+    readonly keyField?: Field.Name;
+    /**
+     *
+     */
+    findField(nameOrPath: string): ApiField | undefined;
+    /**
+     *
+     */
+    getField(nameOrPath: string): ApiField;
+    /**
+     *
+     */
+    parseFieldPath(fieldPath: string, options?: {
+        allowSigns?: 'first' | 'each';
+    }): ComplexType.ParsedFieldPath[];
+    /**
+     *
+     */
+    normalizeFieldPath(fieldPath: string, options?: {
+        allowSigns?: 'first' | 'each';
+    }): string;
+    /**
+     *
+     */
+    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
+    protected _generateSchema(codec: 'encode' | 'decode', context: StrictOmit<DataType.GenerateCodecOptions, 'projection'> & {
+        currentPath: string;
+        projection?: FieldsProjection | '*';
+    }): IsObject.Schema;
+    protected _generateFieldCodec(codec: 'encode' | 'decode', field: ApiField, context: StrictOmit<DataType.GenerateCodecOptions, 'projection'> & {
+        currentPath: string;
+        projection?: FieldsProjection;
+    }): Validator;
+}
+export {};