@opra/common 0.4.0 → 0.6.0

package/esm/schema/index.d.ts

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+export * from './constants.js';
+export * from './types.js';
+export * from './opra-schema.definition.js';
+export * from './decorators/opr-complex-type.decorator.js';
+export * from './decorators/opr-field.decorator.js';
+export * from './decorators/opr-collection-resource.decorator.js';
+export * from './decorators/opr-singleton-resource.decorator.js';
+export * from './decorators/opr-resolver.decorator.js';
+export * from './interfaces/resource-container.interface.js';
+export * from './implementation/document-builder.js';
+export * from './implementation/opra-document.js';
+export * from './implementation/data-type/data-type.js';
+export * from './implementation/data-type/complex-type.js';
+export * from './implementation/data-type/simple-type.js';
+export * from './implementation/data-type/union-type.js';
+export * from './implementation/resource/resource-info.js';
+export * from './implementation/resource/container-resource-info.js';
+export * from './implementation/resource/collection-resource-info.js';
+export * from './implementation/resource/singleton-resource-info.js';
+export * from './implementation/query/index.js';
+export * from './type-helpers/mixin-type.helper.js';
+export * from './type-helpers/extend-type.helper.js';
+export * from './implementation/schema-builder/extract-type-metadata.util.js';
+export * from './implementation/schema-builder/extract-resource-metadata.util.js';

package/esm/schema/index.js

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+export * from './constants.js';
+export * from './types.js';
+export * from './opra-schema.definition.js';
+export * from './decorators/opr-complex-type.decorator.js';
+export * from './decorators/opr-field.decorator.js';
+export * from './decorators/opr-collection-resource.decorator.js';
+export * from './decorators/opr-singleton-resource.decorator.js';
+export * from './decorators/opr-resolver.decorator.js';
+export * from './interfaces/resource-container.interface.js';
+export * from './implementation/document-builder.js';
+export * from './implementation/opra-document.js';
+export * from './implementation/data-type/data-type.js';
+export * from './implementation/data-type/complex-type.js';
+export * from './implementation/data-type/simple-type.js';
+export * from './implementation/data-type/union-type.js';
+export * from './implementation/resource/resource-info.js';
+export * from './implementation/resource/container-resource-info.js';
+export * from './implementation/resource/collection-resource-info.js';
+export * from './implementation/resource/singleton-resource-info.js';
+export * from './implementation/query/index.js';
+export * from './type-helpers/mixin-type.helper.js';
+export * from './type-helpers/extend-type.helper.js';
+export * from './implementation/schema-builder/extract-type-metadata.util.js';
+export * from './implementation/schema-builder/extract-resource-metadata.util.js';

package/esm/schema/interfaces/child-field-query.interface.d.ts

@@ -0,0 +1,4 @@
+import type { FieldGetQueryOptions } from '../implementation/query/index.js';
+export interface IChildFieldQuery {
+    child?: FieldGetQueryOptions;
+}

package/esm/schema/interfaces/child-field-query.interface.js

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

package/esm/schema/interfaces/data-type.metadata.d.ts

@@ -0,0 +1,18 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../opra-schema.definition.js';
+import { TypeThunkAsync } from '../types.js';
+export declare type SimpleTypeMetadata = OpraSchema.SimpleType & {
+    name: string;
+};
+export declare type ComplexTypeMetadata = StrictOmit<OpraSchema.ComplexType, 'fields' | 'extends'> & {
+    name: string;
+    extends?: ComplexTypeExtendingMetadata[];
+    fields?: Record<string, FieldMetadata>;
+};
+export declare type FieldMetadata = StrictOmit<OpraSchema.Field, 'type'> & {
+    type?: string | TypeThunkAsync | (string | TypeThunkAsync)[];
+};
+declare type ComplexTypeExtendingMetadata = StrictOmit<OpraSchema.ComplexTypeExtendingInfo, 'type'> & {
+    type: string | Type;
+};
+export {};

package/esm/schema/interfaces/data-type.metadata.js

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

package/esm/schema/interfaces/resource-container.interface.d.ts

@@ -0,0 +1,8 @@
+import { CollectionResourceInfo } from '../implementation/resource/collection-resource-info.js';
+import { ResourceInfo } from '../implementation/resource/resource-info.js';
+import { SingletonResourceInfo } from '../implementation/resource/singleton-resource-info.js';
+export interface IResourceContainer {
+    getResource<T extends ResourceInfo>(name: string): T;
+    getCollectionResource(name: string): CollectionResourceInfo;
+    getSingletonResource(name: string): SingletonResourceInfo;
+}

package/esm/schema/interfaces/resource-container.interface.js

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

package/esm/schema/interfaces/resource.metadata.d.ts

@@ -0,0 +1,18 @@
+import { PartialSome, StrictOmit } from 'ts-gems';
+import { OpraSchema } from '../opra-schema.definition.js';
+import { TypeThunkAsync } from '../types.js';
+export declare type CollectionResourceMetadata = PartialSome<StrictOmit<OpraSchema.CollectionResource, 'type'>, 'keyFields'> & {
+    type: TypeThunkAsync | string;
+    name: string;
+};
+export declare type SingletonResourceMetadata = StrictOmit<OpraSchema.SingletonResource, 'type'> & {
+    type: TypeThunkAsync | string;
+    name: string;
+};
+export declare type ICreateResolverMetadata = StrictOmit<OpraSchema.CreateMethodResolver, 'handler'>;
+export declare type IDeleteResolverMetadata = StrictOmit<OpraSchema.DeleteMethodResolver, 'handler'>;
+export declare type IDeleteManyResolverMetadata = StrictOmit<OpraSchema.DeleteManyMethodResolver, 'handler'>;
+export declare type IGetResolverMetadata = StrictOmit<OpraSchema.GetMethodResolver, 'handler'>;
+export declare type IUpdateResolverMetadata = StrictOmit<OpraSchema.UpdateMethodResolver, 'handler'>;
+export declare type IUpdateManyResolverMetadata = StrictOmit<OpraSchema.UpdateManyMethodResolver, 'handler'>;
+export declare type ISearchResolverMetadata = StrictOmit<OpraSchema.SearchMethodResolver, 'handler'>;

package/esm/schema/interfaces/resource.metadata.js

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

package/esm/schema/opra-schema.definition.d.ts

@@ -0,0 +1,178 @@
+import { Type } from 'ts-gems';
+import { ComparisonOperator } from '../filter/index.js';
+export declare namespace OpraSchema {
+    /**
+     * *** === Constants === ***
+     */
+    export const Version = "1.0";
+    /**
+     * *** === Type definitions === ***
+     */
+    export type Extensible<T = any> = {
+        [key: `$${string}`]: T;
+    };
+    export type ResourceKind = 'ContainerResource' | 'CollectionResource' | 'SingletonResource';
+    export type DataTypeKind = 'SimpleType' | 'ComplexType' | 'UnionType';
+    export type SingletonMethod = 'get' | 'create' | 'update' | 'delete';
+    export type CollectionMethod = SingletonMethod | 'search' | 'count' | 'updateMany' | 'deleteMany';
+    /**
+     * *** === Document related === ***
+     */
+    export interface Document {
+        version: string;
+        info: DocumentInfo;
+        references?: Record<string, Reference>;
+        types?: Record<string, DataType>;
+        resources?: Record<string, Resource>;
+        servers?: ServerInfo[];
+    }
+    export type ServerInfo = Extensible & {
+        url: string;
+        description?: string;
+    };
+    export type Reference = Extensible & {
+        url?: string;
+        document?: Document;
+    };
+    export type DocumentInfo = Extensible & {
+        title: string;
+        version: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: ContactPerson[];
+        license?: LicenseInfo;
+    };
+    export type ContactPerson = Extensible & {
+        name?: string;
+        email?: string;
+        url?: string;
+    };
+    export type LicenseInfo = Extensible & {
+        name: string;
+        url?: string;
+        content?: string;
+    };
+    /**
+     * *** === Data Type related === ***
+     */
+    export type DataType = ComplexType | SimpleType | UnionType;
+    export type BaseDataType = {
+        kind: DataTypeKind;
+        description?: string;
+        ctor?: Type;
+        parse?: (v: any) => any;
+        serialize?: (v: any) => any;
+    };
+    export interface SimpleType extends BaseDataType {
+        kind: 'SimpleType';
+    }
+    export interface UnionType extends BaseDataType {
+        kind: 'UnionType';
+        types: DataType[];
+    }
+    export interface ComplexType extends BaseDataType {
+        kind: 'ComplexType';
+        description?: string;
+        abstract?: boolean;
+        extends?: ComplexTypeExtendingInfo[];
+        fields?: Record<string, Field>;
+        additionalFields?: boolean | string | Pick<Field, 'type' | 'format' | 'isArray' | 'enum'>;
+    }
+    export interface ComplexTypeExtendingInfo {
+        type: string;
+        pick?: string[];
+        omit?: string[];
+    }
+    export type Field = Extensible & {
+        type: string;
+        description?: string;
+        required?: boolean;
+        isArray?: boolean;
+        format?: string;
+        default?: any;
+        fixed?: string | number;
+        enum?: string | string[] | Record<string, string>;
+        enumName?: string;
+        examples?: any[] | Record<string, any>;
+        deprecated?: boolean | string;
+        /**
+         * If true, this property will not be included in results by default.
+         * The client side should include the property name in the "include" query parameter.
+         */
+        exclusive?: boolean;
+    };
+    /**
+     * *** === Resource related === ***
+     */
+    export type Resource = ContainerResource | CollectionResource | SingletonResource;
+    export interface BaseResource {
+        kind: ResourceKind;
+        description?: string;
+        instance?: {};
+    }
+    export interface CollectionResource extends BaseResource {
+        kind: 'CollectionResource';
+        type: string;
+        keyFields: string | string[];
+        create?: CreateMethodResolver;
+        count?: CountMethodResolver;
+        delete?: DeleteMethodResolver;
+        deleteMany?: DeleteManyMethodResolver;
+        get?: GetMethodResolver;
+        update?: UpdateMethodResolver;
+        updateMany?: UpdateManyMethodResolver;
+        search?: SearchMethodResolver;
+    }
+    export interface SingletonResource extends BaseResource {
+        kind: 'SingletonResource';
+        type: string;
+        create?: CreateMethodResolver;
+        get?: GetMethodResolver;
+        update?: UpdateMethodResolver;
+        delete?: DeleteMethodResolver;
+    }
+    export interface ContainerResource extends BaseResource {
+        kind: 'ContainerResource';
+        resources: Resource[];
+    }
+    export type MethodResolver = {
+        handler?: Function;
+    };
+    type MethodResolverInputOptions = {
+        inputPick?: string[];
+        inputOmit?: string[];
+    };
+    type MethodResolverOutputOptions = {
+        outputPick?: string[];
+        outputOmit?: string[];
+    };
+    type MethodResolverFilterOptions = {
+        filters?: {
+            field: string;
+            operators?: ComparisonOperator[];
+        }[];
+    };
+    export type CreateMethodResolver = MethodResolver & MethodResolverInputOptions & MethodResolverOutputOptions;
+    export type CountMethodResolver = MethodResolver & {};
+    export type DeleteMethodResolver = MethodResolver & {};
+    export type DeleteManyMethodResolver = MethodResolver & MethodResolverFilterOptions;
+    export type GetMethodResolver = MethodResolver & MethodResolverOutputOptions;
+    export type UpdateMethodResolver = MethodResolver & MethodResolverInputOptions & MethodResolverOutputOptions;
+    export type UpdateManyMethodResolver = MethodResolver & MethodResolverFilterOptions;
+    export type SearchMethodResolver = MethodResolver & MethodResolverOutputOptions & {
+        sortFields?: string[];
+        defaultSort?: string[];
+    } & MethodResolverFilterOptions;
+    /**
+     * *** === Type Guards === ***
+     */
+    export function isDataType(obj: any): obj is DataType;
+    export function isComplexType(obj: any): obj is ComplexType;
+    export function isSimpleType(obj: any): obj is SimpleType;
+    export function isUnionTypee(obj: any): obj is UnionType;
+    export function isResource(obj: any): obj is Resource;
+    export function isCollectionResource(obj: any): obj is CollectionResource;
+    export function isSingletonResource(obj: any): obj is SingletonResource;
+    export function isContainerResource(obj: any): obj is ContainerResource;
+    export {};
+}

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

@@ -0,0 +1,46 @@
+export var OpraSchema;
+(function (OpraSchema) {
+    /**
+     * *** === Constants === ***
+     */
+    OpraSchema.Version = '1.0';
+    /**
+     * *** === Type Guards === ***
+     */
+    function isDataType(obj) {
+        return obj && typeof obj === 'object' &&
+            (obj.kind === 'ComplexType' || obj.kind === 'SimpleType' || obj.kind === 'UnionType');
+    }
+    OpraSchema.isDataType = isDataType;
+    function isComplexType(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'ComplexType';
+    }
+    OpraSchema.isComplexType = isComplexType;
+    function isSimpleType(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'SimpleType';
+    }
+    OpraSchema.isSimpleType = isSimpleType;
+    function isUnionTypee(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'UnionType';
+    }
+    OpraSchema.isUnionTypee = isUnionTypee;
+    function isResource(obj) {
+        return obj && typeof obj === 'object' &&
+            obj.kind === 'ContainerResource' ||
+            obj.kind === 'CollectionResource' ||
+            obj.kind === 'SingletonResource';
+    }
+    OpraSchema.isResource = isResource;
+    function isCollectionResource(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'CollectionResource';
+    }
+    OpraSchema.isCollectionResource = isCollectionResource;
+    function isSingletonResource(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'SingletonResource';
+    }
+    OpraSchema.isSingletonResource = isSingletonResource;
+    function isContainerResource(obj) {
+        return obj && typeof obj === 'object' && obj.kind === 'ContainerResource';
+    }
+    OpraSchema.isContainerResource = isContainerResource;
+})(OpraSchema || (OpraSchema = {}));

package/esm/schema/type-helpers/extend-type.helper.d.ts

@@ -0,0 +1,3 @@
+import { Class } from 'ts-gems';
+export declare function PickType<T extends any[], I1, S1, K extends keyof I1>(classRef: Class<T, I1, S1>, keys: readonly K[]): Class<T, Pick<I1, K>> & Omit<Pick<S1, keyof typeof classRef>, 'prototype' | 'constructor'>;
+export declare function OmitType<T extends any[], I1, S1, K extends keyof I1>(classRef: Class<T, I1, S1>, keys: readonly K[]): Class<T, Omit<I1, K>> & Omit<Pick<S1, keyof typeof classRef>, 'prototype' | 'constructor'>;

package/esm/schema/type-helpers/extend-type.helper.js

@@ -0,0 +1,59 @@
+import * as Optionals from '@opra/optionals';
+import { DATATYPE_METADATA, MAPPED_TYPE_METADATA } from '../constants.js';
+import { applyMixins, inheritPropertyInitializers } from './mixin.utils.js';
+export function PickType(classRef, keys) {
+    return ExtendType(classRef, classRef, { pickKeys: keys });
+}
+export function OmitType(classRef, keys) {
+    return ExtendType(classRef, classRef, { omitKeys: keys });
+}
+function ExtendType(classRef, orgClassRef, options) {
+    const pickKeys = options.pickKeys && options.pickKeys.map(x => String(x).toLowerCase());
+    const omitKeys = options.omitKeys && options.omitKeys.map(x => String(x).toLowerCase());
+    const isInheritedPredicate = (propertyName) => {
+        if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
+            return false;
+        if (pickKeys)
+            return pickKeys.includes(propertyName.toLowerCase());
+        return true;
+    };
+    // const isRequiredPredicate = (propertyName: string): boolean | undefined => {
+    //   if (options.requiredKeys && options.requiredKeys.includes(propertyName as RequiredKey))
+    //     return true;
+    //   if (options.partialKeys && options.partialKeys.includes(propertyName as PartialKey))
+    //     return false;
+    //   return;
+    // };
+    class MappedClass {
+        constructor() {
+            inheritPropertyInitializers(this, classRef, isInheritedPredicate);
+        }
+    }
+    applyMixins(MappedClass, classRef);
+    const mappedTypeMetadata = [];
+    const m = Reflect.getOwnMetadata(DATATYPE_METADATA, classRef);
+    if (m) {
+        if (!(m.kind === 'ComplexType'))
+            throw new TypeError(`Class "${classRef}" is not a ComplexType`);
+        const meta = {
+            type: classRef
+        };
+        if (options.pickKeys)
+            meta.pick = options.pickKeys;
+        if (options.omitKeys)
+            meta.omit = options.omitKeys;
+        mappedTypeMetadata.push(meta);
+    }
+    else
+        throw new TypeError(`Class "${classRef}" doesn't have datatype metadata information`);
+    if (Optionals.SqbConnect) {
+        const { Entity, EntityMetadata } = Optionals.SqbConnect;
+        const srcMeta = Entity.getMetadata(classRef);
+        if (srcMeta) {
+            const trgMeta = EntityMetadata.define(MappedClass);
+            EntityMetadata.mixin(trgMeta, srcMeta, k => isInheritedPredicate(k));
+        }
+    }
+    Reflect.defineMetadata(MAPPED_TYPE_METADATA, mappedTypeMetadata, MappedClass);
+    return MappedClass;
+}

package/esm/schema/type-helpers/mixin-type.helper.d.ts

@@ -0,0 +1,2 @@
+import { Class } from 'ts-gems';
+export declare function MixinType<A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, c4?: Class<A4, I4, S4>): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;

package/esm/schema/type-helpers/mixin-type.helper.js

@@ -0,0 +1,41 @@
+import * as Optionals from '@opra/optionals';
+import { DATATYPE_METADATA, MAPPED_TYPE_METADATA } from '../constants.js';
+import { applyMixins, inheritPropertyInitializers } from './mixin.utils.js';
+export function MixinType(c1, c2, c3, c4) {
+    const clasRefs = [...arguments].filter(x => !!x);
+    if (!clasRefs.length)
+        throw new TypeError('You must provide base classeses');
+    if (clasRefs.length === 1)
+        return clasRefs[0];
+    class MappedClass {
+        constructor() {
+            for (const c of clasRefs)
+                inheritPropertyInitializers(this, c);
+        }
+    }
+    const mappedTypeMetadata = [];
+    for (const c of clasRefs) {
+        const m = Reflect.getOwnMetadata(DATATYPE_METADATA, c);
+        if (m) {
+            if (!(m.kind === 'ComplexType'))
+                throw new TypeError(`Class "${c}" is not a ComplexType`);
+            mappedTypeMetadata.push({
+                type: c
+            });
+        }
+        else if (Reflect.hasMetadata(MAPPED_TYPE_METADATA, c)) {
+            const mtm = Reflect.getMetadata(MAPPED_TYPE_METADATA, c);
+            if (mtm)
+                mappedTypeMetadata.push(...mtm);
+        }
+        else
+            throw new TypeError(`Class "${c}" doesn't have datatype metadata information`);
+        applyMixins(MappedClass, c);
+    }
+    if (Optionals.SqbConnect) {
+        const { Entity } = Optionals.SqbConnect;
+        Entity.mixin(MappedClass, ...clasRefs);
+    }
+    Reflect.defineMetadata(MAPPED_TYPE_METADATA, mappedTypeMetadata, MappedClass);
+    return MappedClass;
+}

package/esm/schema/type-helpers/mixin.utils.d.ts

@@ -0,0 +1,3 @@
+import { Type } from 'ts-gems';
+export declare function applyMixins(derivedCtor: any, baseCtor: any, filter?: (k: string) => boolean): void;
+export declare function inheritPropertyInitializers(target: Record<string, any>, sourceClass: Type, isPropertyInherited?: (key: string) => boolean): void;

package/esm/schema/type-helpers/mixin.utils.js

@@ -0,0 +1,27 @@
+export function applyMixins(derivedCtor, baseCtor, filter) {
+    for (const k of Object.getOwnPropertyNames(baseCtor.prototype)) {
+        if ((k === 'constructor' || k === '__proto__' || k === 'toJSON' || k === 'toString') ||
+            filter && !filter(k))
+            continue;
+        Object.defineProperty(derivedCtor.prototype, k, Object.getOwnPropertyDescriptor(baseCtor.prototype, k) ||
+            Object.create(null));
+    }
+}
+export function inheritPropertyInitializers(target, sourceClass, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+isPropertyInherited = (key) => true) {
+    try {
+        const tempInstance = new sourceClass();
+        const propertyNames = Object.getOwnPropertyNames(tempInstance);
+        propertyNames
+            .filter((propertyName) => typeof tempInstance[propertyName] !== 'undefined' &&
+            typeof target[propertyName] === 'undefined')
+            .filter((propertyName) => isPropertyInherited(propertyName))
+            .forEach((propertyName) => {
+            target[propertyName] = tempInstance[propertyName];
+        });
+    }
+    catch {
+        //
+    }
+}

package/esm/{types.d.ts → schema/types.d.ts}

@@ -1,7 +1,14 @@
-import { Builtin, DeepPickWritable } from 'ts-gems';
+import { Builtin, DeepPickWritable, Type } from 'ts-gems';
 export declare type PartialInput<T> = DeepNullablePartial<DeepPickWritable<T>>;
 export declare type PartialOutput<T> = DeepNullablePartial<T>;
 declare type DeepNullablePartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullablePartial<U>> : T extends (infer U)[] ? DeepNullablePartial<U>[] : {
     [P in keyof T]?: DeepNullablePartial<Exclude<T[P], undefined>> | null;
 };
+export declare type Thunk<T> = T | (() => T);
+export declare type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
+export declare type TypeThunk<T = any> = Thunk<Type<T>>;
+export declare type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
+export declare type Named<T> = T & {
+    name: string;
+};
 export {};

package/esm/schema/types.js

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

package/esm/schema/utils/class.utils.d.ts

@@ -0,0 +1,2 @@
+import { Type } from 'ts-gems';
+export declare function isConstructor(obj: any): obj is Type;

package/esm/schema/utils/class.utils.js

@@ -0,0 +1,4 @@
+export function isConstructor(obj) {
+    return typeof obj === 'function' &&
+        !!(obj.prototype && obj.prototype.constructor);
+}

package/esm/schema/utils/clone-object.util.d.ts

@@ -0,0 +1 @@
+export declare function cloneObject<T extends {}>(obj: T, jsonOnly?: boolean): T;

package/esm/schema/utils/clone-object.util.js

@@ -0,0 +1,14 @@
+import isPlainObject from 'putil-isplainobject';
+import merge from 'putil-merge';
+export function cloneObject(obj, jsonOnly) {
+    return merge({}, obj, {
+        deep: true,
+        clone: true,
+        filter: (source, key) => {
+            const v = source[key];
+            return v != null &&
+                !jsonOnly || (typeof v !== 'function' &&
+                (typeof v !== 'object' || isPlainObject(v) || Array.isArray(v)));
+        }
+    });
+}

package/esm/schema/utils/inspect.util.d.ts

@@ -0,0 +1,4 @@
+export declare const nodeInspectCustom: unique symbol;
+export declare const colorReset = "\u001B[0m";
+export declare const colorFgYellow = "\u001B[33m";
+export declare const colorFgMagenta = "\u001B[35m";

package/esm/schema/utils/inspect.util.js

@@ -0,0 +1,4 @@
+export const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
+export const colorReset = "\x1b[0m";
+export const colorFgYellow = "\x1b[33m";
+export const colorFgMagenta = "\x1b[35m";

package/esm/schema/utils/normalize-field-array.util.d.ts

@@ -0,0 +1,3 @@
+import { ComplexType } from '../implementation/data-type/complex-type.js';
+import type { OpraDocument } from '../implementation/opra-document.js';
+export declare function normalizeFieldArray(document: OpraDocument, dataType: ComplexType | undefined, fields: string[], parentPath?: string): string[];

package/esm/schema/utils/normalize-field-array.util.js

@@ -0,0 +1,40 @@
+import { ComplexType } from '../implementation/data-type/complex-type.js';
+import { pathToTree } from './path-to-tree.util.js';
+export function normalizeFieldArray(document, dataType, fields, parentPath = '') {
+    const fieldsTree = pathToTree(fields) || {};
+    return _normalizeFieldsList([], document, dataType, fieldsTree, '', parentPath, {
+        additionalFields: true
+    });
+}
+function _normalizeFieldsList(target, document, dataType, node, parentPath = '', actualPath = '', options) {
+    let curPath = '';
+    for (const k of Object.keys(node)) {
+        const nodeVal = node[k];
+        const prop = dataType?.fields.get(k);
+        if (!prop) {
+            curPath = parentPath ? parentPath + '.' + k : k;
+            if (!options?.additionalFields || (dataType && !dataType.additionalFields))
+                throw new TypeError(`Unknown field "${curPath}"`);
+            if (typeof nodeVal === 'object')
+                _normalizeFieldsList(target, document, undefined, nodeVal, curPath, actualPath, options);
+            else
+                target.push(curPath);
+            continue;
+        }
+        curPath = parentPath ? parentPath + '.' + prop.name : prop.name;
+        const propType = document.getDataType(prop.type || 'string');
+        if (typeof nodeVal === 'object') {
+            if (!(propType && propType instanceof ComplexType))
+                throw new TypeError(`"${(actualPath ? actualPath + '.' + curPath : curPath)}" is not a complex type and has no sub fields`);
+            if (target.findIndex(x => x === parentPath) >= 0)
+                continue;
+            target = _normalizeFieldsList(target, document, propType, nodeVal, curPath, actualPath, options);
+            continue;
+        }
+        if (target.findIndex(x => x.startsWith(curPath + '.')) >= 0) {
+            target = target.filter(x => !x.startsWith(curPath + '.'));
+        }
+        target.push(curPath);
+    }
+    return target;
+}

package/esm/schema/utils/path-to-tree.util.d.ts

@@ -0,0 +1,4 @@
+export interface ObjectTree {
+    [key: string]: boolean | ObjectTree;
+}
+export declare function pathToTree(arr: string[]): ObjectTree | undefined;

package/esm/schema/utils/path-to-tree.util.js

@@ -0,0 +1,22 @@
+const dotPattern = /^([^.]+)\.(.*)$/;
+export function pathToTree(arr) {
+    if (!arr.length)
+        return;
+    return _stringPathToObjectTree(arr, {});
+}
+function _stringPathToObjectTree(arr, target) {
+    for (const k of arr) {
+        const m = dotPattern.exec(k);
+        if (m) {
+            const key = m[1];
+            if (target[key] === true)
+                continue;
+            const sub = target[key] = typeof target[key] === 'object' ? target[key] : {};
+            _stringPathToObjectTree([m[2]], sub);
+        }
+        else {
+            target[k] = true;
+        }
+    }
+    return target;
+}

package/esm/schema/utils/string-compare.util.d.ts

@@ -0,0 +1 @@
+export declare function stringCompare(a: string, b: string): number;

package/esm/schema/utils/string-compare.util.js

@@ -0,0 +1,7 @@
+export function stringCompare(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}

package/esm/url/formats/boolean-format.d.ts

@@ -0,0 +1,5 @@
+import { Format } from './format.js';
+export declare class BooleanFormat extends Format {
+    parse(value: string): boolean;
+    stringify(value: any): string;
+}