@opra/common 0.33.13 → 1.0.0-alpha.10

package/types/helpers/parse-fields-projection.d.ts

@@ -0,0 +1,11 @@
+export declare class FieldsProjection {
+    [key: string]: FieldsProjection.Item;
+}
+export declare namespace FieldsProjection {
+    class Item {
+        sign?: string;
+        projection?: FieldsProjection;
+    }
+}
+export declare function parseFieldsProjection(projection: string | string[], keepCase?: boolean): FieldsProjection | undefined;
+export declare function parse(input: string, target: FieldsProjection): void;

package/types/helpers/responsive-map.d.ts

@@ -3,20 +3,24 @@ export interface ResponsiveMapOptions {
     caseSensitive?: boolean;
 }
 export type ResponsiveMapInit<V> = ResponsiveMap<V> | Map<string, V> | Record<any, V>;
+declare const kEntries: unique symbol;
 declare const kKeyMap: unique symbol;
-declare const kKeyOrder: unique symbol;
 declare const kWellKnownKeys: unique symbol;
 declare const kOptions: unique symbol;
+declare const kSize: unique symbol;
 /**
  * A Map implementation that supports case-insensitivity and ordered keys
  */
-export declare class ResponsiveMap<V> extends Map<string, V> {
+export declare class ResponsiveMap<V> implements Map<string, V> {
+    private [kSize];
+    private [kEntries];
     private [kKeyMap];
-    private [kKeyOrder];
     private [kWellKnownKeys];
     private [kOptions];
     constructor(init?: ResponsiveMapInit<V> | null, options?: ResponsiveMapOptions);
+    get size(): number;
     clear(): void;
+    forEach(callbackfn: (value: V, key: string, map: Map<string, V>) => void, thisArg?: any): void;
     get(key: string): V | undefined;
     has(key: string): boolean;
     set(key: string, value: V): this;
@@ -26,9 +30,9 @@ export declare class ResponsiveMap<V> extends Map<string, V> {
     entries(): IterableIterator<[string, V]>;
     delete(key: string): boolean;
     sort(compareFn?: (a: string, b: string) => number): this;
-    getProxy(handler?: ProxyHandler<Record<string, V>>): Record<string, V>;
     toObject(): Record<string, V>;
     [Symbol.iterator](): IterableIterator<[string, V]>;
+    get [Symbol.toStringTag](): string;
     protected _getOriginalKey(key: string): string;
     protected _getStoringKey(key: string): string;
 }

package/types/helpers/type-guards.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 /// <reference lib="dom" />
-import { Readable } from 'stream';
+import { Readable, Stream } from 'stream';
 import { Type } from 'ts-gems';
 export declare function isConstructor(fn: any): fn is Type;
-export declare function isStream(stream: any): boolean;
+export declare function isStream(x: any): x is Stream;
 export declare function isReadable(x: any): x is Readable;
 export declare function isWritable(x: any): x is Readable;
 export declare function isReadableStream(x: any): x is ReadableStream;

package/types/http/enums/http-status-messages.d.ts

@@ -1,65 +1,65 @@
 export declare const HttpStatusMessages: {
-    "100": string;
-    "101": string;
-    "102": string;
-    "103": string;
-    "200": string;
-    "201": string;
-    "202": string;
-    "203": string;
-    "204": string;
-    "205": string;
-    "206": string;
-    "207": string;
-    "208": string;
-    "226": string;
-    "300": string;
-    "301": string;
-    "302": string;
-    "303": string;
-    "304": string;
-    "305": string;
-    "307": string;
-    "308": string;
-    "400": string;
-    "401": string;
-    "402": string;
-    "403": string;
-    "404": string;
-    "405": string;
-    "406": string;
-    "407": string;
-    "408": string;
-    "409": string;
-    "410": string;
-    "411": string;
-    "412": string;
-    "413": string;
-    "414": string;
-    "415": string;
-    "416": string;
-    "417": string;
-    "418": string;
-    "421": string;
-    "422": string;
-    "423": string;
-    "424": string;
-    "425": string;
-    "426": string;
-    "428": string;
-    "429": string;
-    "431": string;
-    "451": string;
-    "500": string;
-    "501": string;
-    "502": string;
-    "503": string;
-    "504": string;
-    "505": string;
-    "506": string;
-    "507": string;
-    "508": string;
-    "509": string;
-    "510": string;
-    "511": string;
+    '100': string;
+    '101': string;
+    '102': string;
+    '103': string;
+    '200': string;
+    '201': string;
+    '202': string;
+    '203': string;
+    '204': string;
+    '205': string;
+    '206': string;
+    '207': string;
+    '208': string;
+    '226': string;
+    '300': string;
+    '301': string;
+    '302': string;
+    '303': string;
+    '304': string;
+    '305': string;
+    '307': string;
+    '308': string;
+    '400': string;
+    '401': string;
+    '402': string;
+    '403': string;
+    '404': string;
+    '405': string;
+    '406': string;
+    '407': string;
+    '408': string;
+    '409': string;
+    '410': string;
+    '411': string;
+    '412': string;
+    '413': string;
+    '414': string;
+    '415': string;
+    '416': string;
+    '417': string;
+    '418': string;
+    '421': string;
+    '422': string;
+    '423': string;
+    '424': string;
+    '425': string;
+    '426': string;
+    '428': string;
+    '429': string;
+    '431': string;
+    '451': string;
+    '500': string;
+    '501': string;
+    '502': string;
+    '503': string;
+    '504': string;
+    '505': string;
+    '506': string;
+    '507': string;
+    '508': string;
+    '509': string;
+    '510': string;
+    '511': string;
 };

package/types/http/enums/mime-types.enum.d.ts

@@ -0,0 +1,12 @@
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#successful_responses
+ */
+export declare enum MimeTypes {
+    json = "application/json",
+    opra_response_json = "application/opra.response+json",
+    xml = "application/XML",
+    text = "text/plain",
+    html = "text/html",
+    markdown = "text/markdown",
+    binary = "binary/octet-stream"
+}

package/types/http/index.d.ts

@@ -1,5 +1,4 @@
-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 './enums/mime-types.enum.js';

package/types/i18n/i18n.d.ts

@@ -1,25 +1,28 @@
-import { Type } from 'ts-gems';
-import { FallbackLng, Formatter as I18nextFormatter, i18n, InitOptions as I18nextInitOptions, Resource as I18nextResource, TFunction as I18nextTFunction, TOptions } from '@browsery/i18next';
+import { FallbackLng as I18nextFallbackLng, Formatter as I18nextFormatter, i18n, InitOptions as I18nextInitOptions, Resource as I18nextResource, TFunction as I18nextTFunction, TOptions } from '@browsery/i18next';
 import * as I18next from '@browsery/i18next';
-export type BaseI18n = Type<I18next.i18n>;
-export declare const BaseI18n: BaseI18n;
-export type DeepTranslateOptions = TOptions & {
-    ignore?: (input: any, inst: i18n) => boolean;
-};
-export type InitCallback = I18next.Callback;
-export type TranslateFunction = I18nextTFunction;
-export type Formatter = I18nextFormatter;
-export type LanguageResource = I18nextResource;
-export type { FallbackLng };
-export interface InitOptions extends I18nextInitOptions {
-    resourceDirs?: string[];
+import { Type } from 'ts-gems';
+export interface BaseI18n extends Type<I18next.i18n> {
 }
+export declare namespace I18n {
+    interface InitOptions extends I18nextInitOptions {
+        resourceDirs?: string[];
+    }
+    type DeepTranslateOptions = TOptions & {
+        ignore?: (input: any, inst: i18n) => boolean;
+    };
+    type InitCallback = I18next.Callback;
+    type TranslateFunction = I18nextTFunction;
+    type Formatter = I18nextFormatter;
+    type LanguageResource = I18nextResource;
+    type FallbackLng = I18nextFallbackLng;
+}
+export declare const BaseI18n: BaseI18n;
 export declare class I18n extends BaseI18n {
-    init(callback?: InitCallback): Promise<TranslateFunction>;
-    init(options: InitOptions, callback?: InitCallback): Promise<TranslateFunction>;
-    deep(input: any, options?: DeepTranslateOptions): any;
-    createInstance(options: {} | undefined, callback: any): I18n;
-    static createInstance(options?: InitOptions, callback?: InitCallback): I18n;
-    protected _deepTranslate(input: any, objectStack: WeakMap<object, any>, options?: DeepTranslateOptions): any;
+    init(callback?: I18n.InitCallback): Promise<I18n.TranslateFunction>;
+    init(options: I18n.InitOptions, callback?: I18n.InitCallback): Promise<I18n.TranslateFunction>;
+    deep(input: any, options?: I18n.DeepTranslateOptions): any;
+    createInstance(options?: I18n.InitOptions, callback?: I18n.InitCallback): I18n;
+    static createInstance(options?: I18n.InitOptions, callback?: I18n.InitCallback): I18n;
+    protected _deepTranslate(input: any, objectStack: WeakMap<object, any>, options?: I18n.DeepTranslateOptions): any;
     static get defaultInstance(): I18n;
 }

package/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from './types.js';
 export * from './document/index.js';
 export * from './exception/index.js';
 export * from './filter/index.js';
@@ -6,4 +5,5 @@ export * from './helpers/index.js';
 export * from './http/index.js';
 export * from './i18n/index.js';
 export * from './schema/index.js';
+export * from './types.js';
 export { uid } from 'uid';

package/types/schema/data-type/complex-type.interface.d.ts

@@ -5,11 +5,11 @@ import type { MappedType } from './mapped-type.interface.js';
 import type { MixinType } from './mixin-type.interface.js';
 export interface ComplexType extends StrictOmit<DataTypeBase, 'kind'> {
     kind: ComplexType.Kind;
-    ctor?: Type;
     base?: DataType.Name | ComplexType | MixinType | MappedType;
-    abstract?: boolean;
+    ctor?: Type;
     fields?: Record<Field.Name, Field | DataType.Name>;
-    additionalFields?: boolean | 'error' | string | DataType;
+    additionalFields?: boolean | string | DataType | ['error'] | ['error', string];
+    keyField?: Field.Name;
 }
 export declare namespace ComplexType {
     const Kind = "ComplexType";

package/types/schema/data-type/data-type.interface.d.ts

@@ -11,4 +11,10 @@ export declare namespace DataType {
 export interface DataTypeBase {
     kind: DataType.Kind;
     description?: string;
+    examples?: DataTypeExample[];
+    abstract?: boolean;
+}
+export interface DataTypeExample {
+    description?: string;
+    value?: any;
 }

package/types/schema/data-type/enum-type.interface.d.ts

@@ -2,15 +2,14 @@ import { StrictOmit } from 'ts-gems';
 import type { DataType, DataTypeBase } from './data-type.interface.js';
 export interface EnumType extends StrictOmit<DataTypeBase, 'kind'> {
     kind: EnumType.Kind;
-    base?: DataType.Name | EnumType;
-    values: Record<EnumType.Value, EnumType.ValueInfo>;
+    base?: DataType.Name;
+    attributes: Record<string | number, EnumType.ValueInfo>;
 }
 export declare namespace EnumType {
     const Kind = "EnumType";
     type Kind = typeof Kind;
-    type Value = string | number;
     interface ValueInfo {
-        key?: string;
+        alias?: string;
         description?: string;
     }
 }

package/types/schema/data-type/field.interface.d.ts

@@ -4,7 +4,7 @@ export declare namespace Field {
     type QualifiedName = string;
 }
 export type Field = {
-    type: DataType.Name | DataType;
+    type?: DataType.Name | DataType;
     /**
      * Defines the description of the field
      */
@@ -20,7 +20,7 @@ export type Field = {
     /**
      * Indicates the fixed value of the field. The value of the field can not be any other value.
      */
-    fixed?: string | number | boolean;
+    fixed?: any;
     /**
      * Indicates if field value required in create operation
      */
@@ -50,12 +50,4 @@ export type Field = {
      * Indicates if the field is deprecated and can be removed in the next
      */
     deprecated?: boolean | string;
-    /**
-     * Defines RegExp pattern for the field. A String type is required for this option
-     */
-    pattern?: string;
-    /**
-     * Indicates if partial update enabled for this field
-     */
-    partialUpdate?: boolean;
 };

package/types/schema/data-type/mapped-type.interface.d.ts

@@ -1,11 +1,15 @@
 import { StrictOmit } from 'ts-gems';
-import { ComplexType } from './complex-type.interface.js';
-import { Field } from './field.interface.js';
-export interface MappedType extends StrictOmit<ComplexType, 'kind'> {
+import type { ComplexType } from './complex-type.interface';
+import type { DataType, DataTypeBase } from './data-type.interface';
+import type { Field } from './field.interface.js';
+import type { MixinType } from './mixin-type.interface.js';
+export interface MappedType extends StrictOmit<DataTypeBase, 'kind'> {
     kind: MappedType.Kind;
+    base: DataType.Name | ComplexType | MixinType | MappedType;
     omit?: Field.Name[];
     pick?: Field.Name[];
     partial?: Field.Name[] | boolean;
+    required?: Field.Name[] | boolean;
 }
 export declare namespace MappedType {
     const Kind = "MappedType";

package/types/schema/data-type/mixin-type.interface.d.ts

@@ -1,8 +1,8 @@
 import { StrictOmit } from 'ts-gems';
 import type { ComplexType } from './complex-type.interface.js';
-import type { DataType } from './data-type.interface.js';
+import type { DataType, DataTypeBase } from './data-type.interface.js';
 import type { MappedType } from './mapped-type.interface.js';
-export interface MixinType extends StrictOmit<ComplexType, 'kind'> {
+export interface MixinType extends StrictOmit<DataTypeBase, 'kind'> {
     kind: MixinType.Kind;
     types: (DataType.Name | ComplexType | MixinType | MappedType)[];
 }

package/types/schema/data-type/simple-type.interface.d.ts

@@ -1,14 +1,46 @@
-import { StrictOmit } from 'ts-gems';
-import { Validator } from 'valgen';
-import type { DataTypeBase } from './data-type.interface.js';
-import { DataType } from './data-type.interface.js';
+import type { StrictOmit } from 'ts-gems';
+import type { DataType, DataTypeBase } from './data-type.interface.js';
+/**
+ *
+ * @interface SimpleType
+ */
 export interface SimpleType extends StrictOmit<DataTypeBase, 'kind'> {
     kind: SimpleType.Kind;
-    base?: DataType.Name | SimpleType;
-    decoder?: Validator;
-    encoder?: Validator;
+    base?: DataType.Name;
+    attributes?: Record<string, Attribute>;
+    properties?: Record<string, any>;
+    /**
+     * Naming alternatives across software languages
+     */
+    nameMappings?: Record<string, string>;
 }
 export declare namespace SimpleType {
     const Kind = "SimpleType";
     type Kind = 'SimpleType';
 }
+/**
+ *
+ * @interface Attribute
+ */
+export interface Attribute {
+    /**
+     * Data format of the attribute
+     */
+    format?: string;
+    /**
+     * Defines the description of the attribute
+     */
+    description?: string;
+    /**
+     * Defines the description of the attribute
+     */
+    default?: any;
+    /**
+     * Indicates if the attribute is sealed or not. A sealed attribute cannot be extended/modified through inheritance.
+     */
+    sealed?: boolean;
+    /**
+     * Indicates if the attribute is deprecated and can be removed in the next
+     */
+    deprecated?: boolean | string;
+}

package/types/schema/data-type-container.interface.d.ts

@@ -0,0 +1,7 @@
+import type { DataType } from './data-type/data-type.interface';
+/**
+ * @interface DataTypeContainer
+ */
+export interface DataTypeContainer {
+    types?: Record<DataType.Name, DataType>;
+}

package/types/schema/document.interface.d.ts

@@ -0,0 +1,67 @@
+import type { SpecVersion } from './constants.js';
+import type { DataTypeContainer } from './data-type-container.interface.js';
+import type { HttpController } from './http/http-controller.interface';
+export type Protocol = 'http' | 'ws' | 'rpc';
+/**
+ * @interface Document
+ */
+export interface Document extends DataTypeContainer {
+    spec: SpecVersion;
+    id: string;
+    url?: string;
+    info?: DocumentInfo;
+    references?: Record<string, DocumentReference>;
+    api?: HttpApi;
+}
+/**
+ * @interface DocumentInfo
+ */
+export interface DocumentInfo {
+    title?: string;
+    version?: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactPerson[];
+    license?: LicenseInfo;
+}
+/**
+ * @interface ContactPerson
+ */
+export interface ContactPerson {
+    name?: string;
+    email?: string;
+    url?: string;
+}
+/**
+ * @interface LicenseInfo
+ */
+export interface LicenseInfo {
+    name: string;
+    url?: string;
+    content?: string;
+}
+/**
+ * @interface DocumentReference
+ */
+export interface DocumentReference extends Pick<Document, 'id' | 'url' | 'info'> {
+}
+/**
+ * @interface Api
+ */
+export interface Api extends DataTypeContainer {
+    protocol: Protocol;
+    /**
+     * Name of the api. Should be a computer friendly name
+     */
+    name: string;
+    description?: string;
+}
+/**
+ * @interface HttpApi
+ */
+export interface HttpApi extends Api {
+    protocol: 'http';
+    description?: string;
+    url?: string;
+    controllers: Record<string, HttpController>;
+}

package/types/schema/http/http-controller.interface.d.ts

@@ -0,0 +1,24 @@
+import type { DataTypeContainer } from '../data-type-container.interface.js';
+import type { HttpOperation } from './http-operation.interface';
+import type { HttpParameter } from './http-parameter.interface';
+/**
+ *
+ * @interface HttpController
+ */
+export interface HttpController extends DataTypeContainer {
+    kind: HttpController.Kind;
+    description?: string;
+    path?: string;
+    operations?: Record<string, HttpOperation>;
+    controllers?: Record<string, HttpController>;
+    parameters?: HttpParameter[];
+}
+/**
+ *
+ * @namespace HttpController
+ */
+export declare namespace HttpController {
+    type Name = string;
+    const Kind = "HttpController";
+    type Kind = 'HttpController';
+}

package/types/schema/http/http-media-type.interface.d.ts

@@ -0,0 +1,65 @@
+import type { DataType } from '../data-type/data-type.interface';
+import type { HttpMultipartField } from './http-multipart-field.interface.js';
+/**
+ *
+ * @interface HttpMediaType
+ */
+export interface HttpMediaType {
+    /**
+     * A brief description.
+     * [CommonMark](https://commonmark.org/) syntax MAY be used for rich text representation
+     */
+    description?: string;
+    /**
+     * Media type (MIME) or [range of media types](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2)
+     */
+    contentType?: string | string[];
+    /**
+     * Determines encoding of the content.
+     */
+    contentEncoding?: string;
+    /**
+     * DataType to be used for decoding.
+     */
+    type?: DataType.Name | DataType;
+    /**
+     * Determines if content is array
+     */
+    isArray?: boolean;
+    /**
+     * Example of the content data. The `example` field is mutually exclusive of the `examples` field.
+     */
+    example?: string;
+    /**
+     * Examples of the content data. The `examples` field is mutually exclusive of the `example` field.
+     */
+    examples?: Record<string, string>;
+    /**
+     * Content info for each field for multipart contents
+     */
+    multipartFields?: HttpMultipartField[];
+    /**
+     * Determines maximum number of multipart fields
+     */
+    maxFields?: number;
+    /**
+     * Determines maximum size of each multipart field
+     */
+    maxFieldsSize?: number;
+    /**
+     * Determines maximum number of multipart files
+     */
+    maxFiles?: number;
+    /**
+     * Determines maximum size of each multipart file
+     */
+    maxFileSize?: number;
+    /**
+     * Determines maximum size of all multipart files
+     */
+    maxTotalFileSize?: number;
+    /**
+     * Determines minimum size of each multipart file
+     */
+    minFileSize?: number;
+}

package/types/schema/http/http-multipart-field.interface.d.ts

@@ -0,0 +1,7 @@
+import type { HttpMultipartFieldType } from '../types.js';
+import type { HttpMediaType } from './http-media-type.interface.js';
+export interface HttpMultipartField extends HttpMediaType {
+    fieldName: string | RegExp;
+    fieldType: HttpMultipartFieldType;
+    required?: boolean;
+}

package/types/schema/http/http-operation-response.interface.d.ts

@@ -0,0 +1,24 @@
+import type { HttpMediaType } from './http-media-type.interface.js';
+import type { HttpParameter } from './http-parameter.interface';
+import type { HttpStatusRange } from './http-status-range.interface';
+/**
+ *
+ * @interface HttpOperationResponse
+ */
+export interface HttpOperationResponse extends HttpMediaType {
+    /**
+     * Http status code or code range.
+     * @example 200
+     * @example [401,402,403]
+     * @example {start: 400, end: 403}
+     */
+    statusCode: number | HttpStatusRange | (number | HttpStatusRange)[];
+    /**
+     * Returned parameters for this response. etc. headers or cookies
+     */
+    parameters?: HttpParameter[];
+    /**
+     * Determines if the response object is partial
+     */
+    partial?: boolean | 'deep';
+}