@firmer/mesh 0.0.1

package/README.md

@@ -0,0 +1,24 @@
+# Mesh TypeScript Client
+
+[![Build Status](https://travis-ci.org/ducesoft/babel.svg?branch=master)](https://travis-ci.org/ducesoft/babel)
+[![Financial Contributors on Open Collective](https://opencollective.com/babel/all/badge.svg?label=financial+contributors)](https://opencollective.com/babel) [![codecov](https://codecov.io/gh/babel/babel/branch/master/graph/badge.svg)](https://codecov.io/gh/babel/babel)
+![license](https://img.shields.io/github/license/ducesoft/babel.svg)
+
+中文版 [README](README_CN.md)
+
+## Introduction
+
+Mesh TypeScript client develop kits.
+
+```bash
+cargo install git.firmer.tech/firmer/mesh/client/rust
+```
+
+## Features
+
+Any
+
+## Get Started
+
+Java
+

package/dist/asm/index.d.ts

@@ -0,0 +1,11 @@
+export * from '../cause';
+export * from '../codec';
+export * from '../grpc';
+export * from '../http';
+export * from '../macro';
+export * from '../mpc';
+export * from '../psi';
+export * from '../schema';
+export * from '../system';
+export * from '../tool';
+export * from '../types';

package/dist/cause/codeable.d.ts

@@ -0,0 +1,5 @@
+export interface Codeable {
+    getCode(): string;
+    getMessage(): string;
+}
+export declare function instanceOfCodeable(x: any): boolean;

package/dist/cause/errors.d.ts

@@ -0,0 +1 @@
+export declare function errorf(e: any): Error;

package/dist/cause/index.d.ts

@@ -0,0 +1,3 @@
+export * from './codeable';
+export * from './errors';
+export * from './status';

package/dist/cause/status.d.ts

@@ -0,0 +1,46 @@
+import { Codeable } from './codeable';
+export declare class MeshCode extends Error implements Codeable {
+    constructor(code: string, message: string);
+    readonly code: string;
+    readonly message: string;
+    getCode(): string;
+    getMessage(): string;
+}
+export declare class Status {
+    static SUCCESS: MeshCode;
+    static NOT_FOUND: MeshCode;
+    static SYSTEM_ERROR: MeshCode;
+    static SERVICE_UNAVAILABLE: MeshCode;
+    static VALIDATE: MeshCode;
+    static UNAUTHORIZED: MeshCode;
+    static UNKNOWN: MeshCode;
+    static COMPATIBLE: MeshCode;
+    static TIMEOUT: MeshCode;
+    static NO_PROVIDER: MeshCode;
+    static CRYPT_ERROR: MeshCode;
+    static TOKEN_EXPIRE: MeshCode;
+    static NET_EXPIRE: MeshCode;
+    static NET_DISABLE: MeshCode;
+    static NET_UNAVAILABLE: MeshCode;
+    static LICENSE_FORMAT_ERROR: MeshCode;
+    static LICENSE_EXPIRED: MeshCode;
+    static MAX_REPLICAS_LIMIT: MeshCode;
+    static MAX_COOP_LIMIT: MeshCode;
+    static MAX_TENANT_LIMIT: MeshCode;
+    static MAX_USER_LIMIT: MeshCode;
+    static URN_NOT_PERMIT: MeshCode;
+    static SIGNATURE_ERROR: MeshCode;
+    static CRYPT_CODEC_ERROR: MeshCode;
+    static NO_SERVICE: MeshCode;
+    static NET_NOT_WEAVE: MeshCode;
+    static ADDRESS_ERROR: MeshCode;
+    static UNEXPECTED_SYNTAX: MeshCode;
+    static UNKNOWN_SCRIPT: MeshCode;
+    static DATA_ID_ERROR: MeshCode;
+    static START_PENDING: MeshCode;
+    static UNEXPECTED_SQL_SYNTAX: MeshCode;
+    static NO_DATABASE: MeshCode;
+    static NO_TRANSACTION: MeshCode;
+    static SQL_EXECUTE_ERROR: MeshCode;
+    static DUPLICATE_KEY: MeshCode;
+}

package/dist/codec/codec.d.ts

@@ -0,0 +1,43 @@
+import { Type } from '../macro';
+export declare abstract class Codec {
+    static JSON: string;
+    static PROTOBUF: string;
+    static XML: string;
+    static YAML: string;
+    static THRIFT: string;
+    static MESH: string;
+    /**
+     * Encode object to binary array.
+     *
+     * @param value object
+     * @return binary array
+     */
+    abstract encode(value: any): Uint8Array;
+    /**
+     * Decode to binary array to object.
+     *
+     * @param buffer binary array
+     * @param type   object type
+     * @return typed object
+     */
+    abstract decode<T>(buffer: Uint8Array, type: Type<T>): T;
+    /**
+     * Encode object to string.
+     * @param value
+     */
+    encodeString(value: any): string;
+    /**
+     * Decode object from string.
+     * @param value
+     * @param type
+     */
+    decodeString<T>(value: string, type: Type<T>): T;
+    /**
+     * String to Uint8array
+     */
+    abstract uint8ify<T>(buffer: string): Uint8Array;
+    /**
+     * Uint8array to string.
+     */
+    abstract stringify<T>(buffer: Uint8Array): string;
+}

package/dist/codec/index.d.ts

@@ -0,0 +1,2 @@
+export * from './codec';
+export * from './json';

package/dist/codec/json.d.ts

@@ -0,0 +1,12 @@
+import { Type } from '../macro';
+import { Codec } from './codec';
+export declare class JSONCodec extends Codec {
+    private encoder;
+    private decoder;
+    decode<T>(buffer: Uint8Array, type: Type<T>): T;
+    decorateAny(type: Type<any>, dict: any): any;
+    encode(value: any): Uint8Array;
+    encodeAny(value: any): any;
+    uint8ify<T>(buffer: string): Uint8Array;
+    stringify<T>(buffer: Uint8Array): string;
+}

package/dist/grpc/consumer.d.ts

@@ -0,0 +1,8 @@
+import { Consumer, Execution } from '../mpc';
+import { Context } from '../psi';
+import { Reference } from '../types';
+export declare class GRPCConsumer extends Consumer {
+    start(): void;
+    close(): void;
+    consume(ctx: Context, address: string, urn: string, execution: Execution<Reference>, inbound: Uint8Array): Promise<Uint8Array>;
+}

package/dist/grpc/index.d.ts

@@ -0,0 +1,3 @@
+export * from './consumer';
+export * from './interceptor';
+export * from './provider';

package/dist/grpc/interceptor.d.ts

@@ -0,0 +1,2 @@
+export default class GrpcInterceptor {
+}

package/dist/grpc/provider.d.ts

@@ -0,0 +1,5 @@
+import { Provider } from '../mpc';
+export declare class GRPCProvider extends Provider {
+    start(): void;
+    close(): void;
+}

package/dist/http/consumer.d.ts

@@ -0,0 +1,12 @@
+import { Consumer, Execution } from '../mpc';
+import { Context } from '../psi';
+import { Reference } from '../types';
+import { AxiosInstance } from 'axios';
+export declare class HTTPConsumer extends Consumer {
+    private c;
+    getClient(): Promise<AxiosInstance>;
+    start(): void;
+    close(): void;
+    consume(ctx: Context, address: string, urn: string, execution: Execution<Reference>, inbound: Uint8Array): Promise<Uint8Array>;
+    invoke<T>(param: any, type: T, urn: string, timeout: number): Promise<T>;
+}

package/dist/http/index.d.ts

@@ -0,0 +1,2 @@
+export * from './consumer';
+export * from '../mpc/provider';

package/dist/http/provider.d.ts

@@ -0,0 +1,5 @@
+import { Provider } from '../mpc';
+export declare class HTTPProvider extends Provider {
+    start(): void;
+    close(): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,116 @@
+import { Builtin, Cache, CipherEconomy, CipherProvider, Cluster, Commercialize, Cryptor, DataHouse, Endpoint, Evaluator, Graph, KMS, KV, Licenser, Locker, Network, Pipeline, Publisher, Registry, Savepoint, Scheduler, Sequence, Subscriber, Tokenizer, Transporter, FileSystem, Workflow } from './psi';
+export * from './psi';
+export * from './types';
+export * from './asm';
+interface MeshServices {
+    /**
+      * Builtin
+      */
+    builtin: Builtin;
+    /**
+      * Cache
+      */
+    cache: Cache;
+    /**
+      * CipherEconomy
+      */
+    cipherEconomy: CipherEconomy;
+    /**
+      * CipherProvider
+      */
+    cipherProvider: CipherProvider;
+    /**
+      * Cluster
+      */
+    cluster: Cluster;
+    /**
+      * Commercialize
+      */
+    commercialize: Commercialize;
+    /**
+      * Cryptor
+      */
+    cryptor: Cryptor;
+    /**
+      * DataHouse
+      */
+    dataHouse: DataHouse;
+    /**
+      * Endpoint
+      */
+    endpoint: Endpoint;
+    /**
+      * Evaluator
+      */
+    evaluator: Evaluator;
+    /**
+      * Graph
+      */
+    graph: Graph;
+    /**
+      * KMS
+      */
+    kms: KMS;
+    /**
+      * KV
+      */
+    kv: KV;
+    /**
+      * Licenser
+      */
+    licenser: Licenser;
+    /**
+      * Locker
+      */
+    locker: Locker;
+    /**
+      * Network
+      */
+    network: Network;
+    /**
+      * Pipeline
+      */
+    pipeline: Pipeline;
+    /**
+      * Publisher
+      */
+    publisher: Publisher;
+    /**
+      * Registry
+      */
+    registry: Registry;
+    /**
+      * Savepoint
+      */
+    savepoint: Savepoint;
+    /**
+      * Scheduler
+      */
+    scheduler: Scheduler;
+    /**
+      * Sequence
+      */
+    sequence: Sequence;
+    /**
+      * Subscriber
+      */
+    subscriber: Subscriber;
+    /**
+      * Tokenizer
+      */
+    tokenizer: Tokenizer;
+    /**
+      * Transporter
+      */
+    transporter: Transporter;
+    /**
+      * FileSystem
+      */
+    fileSystem: FileSystem;
+    /**
+      * Workflow
+      */
+    workflow: Workflow;
+}
+declare const MeshService: MeshServices;
+export { MeshService };

package/dist/macro/ark.d.ts

@@ -0,0 +1,84 @@
+import { Dict, List } from './dsa';
+export type Type<T> = Function & {
+    prototype: T;
+};
+export type Class<T> = Type<T> & {
+    new (...args: any[]): T;
+};
+export declare class Types implements Function {
+    readonly raw: Type<any>;
+    readonly parameters: Types[];
+    prototype: any;
+    length: number;
+    arguments: any;
+    caller: Function;
+    name: string;
+    [Symbol.metadata]: DecoratorMetadataObject;
+    constructor(types: any);
+    parse(types: any): any[];
+    apply: (thisArg: any, argArray?: any) => any;
+    call: (thisArg: any, ...argArray: any[]) => any;
+    bind: (thisArg: any, ...argArray: any[]) => any;
+    toString(): string;
+    [Symbol.hasInstance](value: any): boolean;
+}
+declare class ark {
+    private tinder;
+    private annotations;
+    private ak;
+    /**
+     * Annotate handler.
+     * @param target
+     * @param parent
+     * @param macro
+     * @param metadata
+     */
+    annotate(macro: any, target: any, parent: any, metadata: any): void;
+    annotated<T>(parent: any): boolean;
+    /**
+     * Inspect the metadata of target object.
+     * @param parent
+     * @param target
+     * @param macro
+     */
+    metadata<T>(macro: Type<T>, parent: any, target: any): T | undefined;
+    /**
+     * Get all the superclass of kind.
+     */
+    superclass(kind: Type<any>, fn: (sc: Type<any>) => boolean): Type<any>[];
+    /**
+     * Register a annotated object as a metadata.
+     * @param macro annotated decorator
+     * @param name object name
+     * @param kind object type
+     * @param metadata decorated object
+     */
+    register(macro: Type<any>, name: string, kind: Type<any>, metadata: any): void;
+    /**
+     * Unregister the class metadata.
+     * @param macro
+     * @param kind
+     */
+    unregister(macro: Type<any>, kind: Type<any>): void;
+    /**
+     * Export all classes.
+     * @param macro
+     */
+    export(macro: any): Dict<Type<any>, Dict<string, List<Class<any>>>>;
+    /**
+     * Inspect the subclass of kind annotated with macro.
+     * @param macro
+     * @param kind
+     */
+    providers<T>(macro: any, kind: Type<T>): List<Class<T>>;
+    /**
+     * Inspect the subclass of kind annotated with macro for name.
+     * @param macro
+     * @param kind
+     * @param name
+     */
+    provider<T>(macro: Type<any>, kind: Type<T>, name: string): List<Class<T>>;
+    inspect<T>(kind: Type<T>): Dict<string, any>;
+}
+declare const Ark: ark;
+export { Ark };

package/dist/macro/binding.d.ts

@@ -0,0 +1 @@
+export declare function binding(topic?: string, code?: string, version?: string, proto?: string, codec?: string, flags?: number, timeout?: number, meshable?: boolean): ClassDecorator;

package/dist/macro/dsa.d.ts

@@ -0,0 +1,20 @@
+export interface Dict<K, V> extends Map<K, V> {
+    computeIfy(key: K, value: (key: K) => V): V;
+    groupBy<GK>(group: (key: K, value: V) => GK): Dict<GK, V[]>;
+    map<T>(m: (key: K, value: V) => T): List<T>;
+    groupKV<KK, VV>(key: (key: K) => KK, value: (key: K, value: V) => VV): Dict<KK, VV>;
+}
+export declare class dict<K, V> extends Map<K, V> implements Dict<K, V> {
+    computeIfy(key: K, value: (key: K) => V): V;
+    groupBy<GK>(group: (key: K, value: V) => GK): Dict<GK, V[]>;
+    map<T>(m: (key: K, value: V) => T): List<T>;
+    groupKV<KK, VV>(key: (key: K) => KK, value: (key: K, value: V) => VV): Dict<KK, VV>;
+}
+export interface List<T> extends Array<T> {
+    groupBy<K>(group: (value: T) => K): Dict<K, List<T>>;
+    groupKV<K, V>(group: (value: T) => K, value: (key: K, value: T[]) => V): Dict<K, V>;
+}
+export declare class list<T> extends Array implements List<T> {
+    groupBy<K>(group: (value: T) => K): Dict<K, List<T>>;
+    groupKV<K, V>(group: (value: T) => K, value: (key: K, value: T[]) => V): Dict<K, V>;
+}

package/dist/macro/env.d.ts

@@ -0,0 +1,43 @@
+export declare const globalPtr: () => any;
+export declare class Env<T> {
+    static readonly Name: Env<string>;
+    static readonly Direct: Env<string>;
+    static readonly Subset: Env<string>;
+    static readonly Mode: Env<number>;
+    static readonly Proxy: Env<string>;
+    static readonly Address: Env<string>;
+    static readonly Runtime: Env<string>;
+    static readonly MDC: Env<string>;
+    static readonly SPA: Env<string>;
+    static readonly TCP: Env<string>;
+    static readonly Home: Env<string>;
+    static readonly DSN: Env<string>;
+    private readonly name;
+    private readonly value;
+    constructor(name: string, value: () => T);
+    private cache;
+    get(): T;
+    set(v: T): void;
+}
+export declare class Mode {
+    static readonly Disable: Mode;
+    static readonly Failfast: Mode;
+    static readonly Nolog: Mode;
+    static readonly JsonLogFormat: Mode;
+    static readonly PHeader: Mode;
+    static readonly Metrics: Mode;
+    static readonly Debug: Mode;
+    static readonly PermitCirculate: Mode;
+    static readonly NoStdColor: Mode;
+    static readonly Isolate: Mode;
+    static readonly Mock: Mode;
+    private readonly v;
+    constructor(v: number);
+    matches(v: number): boolean;
+    enable(): boolean;
+    value(): number;
+}
+/**
+ * With mesh mode.
+ */
+export declare function withMode(m: number): void;

package/dist/macro/idx.d.ts

@@ -0,0 +1,12 @@
+import { Type } from './ark';
+export declare class Idx {
+    value: number;
+    name: string;
+    transparent: boolean;
+    kind: Type<any>;
+    clas: Type<any>;
+    index: number;
+    constructor(value: number, name: string, transparent: boolean, kind: any);
+    decorate(target: Object, propertyKey: string | symbol | undefined, parameterIndex?: number): void;
+}
+export declare function index(value?: number, name?: string, kind?: any, transparent?: boolean): PropertyDecorator & ParameterDecorator;

package/dist/macro/index.d.ts

@@ -0,0 +1,10 @@
+export * from './ark';
+export * from './binding';
+export * from './dsa';
+export * from './env';
+export * from './idx';
+export * from './inspector';
+export * from './loader';
+export * from './mpi';
+export * from './mps';
+export * from './spi';

package/dist/macro/inspector.d.ts

@@ -0,0 +1,144 @@
+import { Type, Types } from './ark';
+import { Codeable } from '../cause/codeable';
+export interface Inspector {
+    /**
+     * Get inspect parent type.
+     */
+    getType<T>(): Type<T>;
+    /**
+     * Get the name of inspector.
+     */
+    getName(): string;
+    /**
+     * Get the annotations of inspector.
+     */
+    getAnnotation<T>(kind: Type<T>): T | undefined;
+    /**
+     * Get the return type of inspector.
+     */
+    getParameters(): Argument[];
+    /**
+     * Get the origin method.
+     */
+    getReturnType(): Types;
+    /**
+     * Get the executable reference.
+     */
+    getExecutable(): any;
+    /**
+     * Get the symbol of inspector.
+     */
+    getSymbol(): any;
+    /**
+     * Invoke the inspector object.
+     */
+    invoke(target: any, args: any[]): any;
+}
+export interface Accessor {
+    /**
+     * Get the executable accessors.
+     */
+    getMethods(): Inspector[];
+}
+export declare abstract class MethodProxy {
+    /**
+     * Proxy interface.
+     */
+    abstract proxy<T>(kind: Type<T>): T;
+}
+/**
+ * InvocationHandler is the interface implemented by the invocation handler of a proxy instance.
+ * Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance,
+ * the method invocation is encoded and dispatched to the invoke method of its invocation handler.
+ */
+export interface InvocationHandler {
+    invoke(proxy: any, method: Inspector, args: any[]): any;
+}
+export interface Stacktrace {
+    name: string;
+    pos: string;
+    text: string;
+    buff: Uint8Array;
+}
+export interface Parameter {
+    /**
+     * Convert parameters to map.
+     */
+    map(): Map<string, any>;
+    /**
+     * Generic arguments array.
+     */
+    getArguments(): any[];
+    /**
+     * Generic arguments array.
+     */
+    setArguments(args: any[]): void;
+    /**
+     * Get the generic attachments. The attributes will be serialized. The attachments are mutable.
+     */
+    getAttachments(): Map<string, string>;
+    /**
+     * Attachment arguments.
+     */
+    setAttachments(attachments: Map<string, string>): void;
+}
+export interface Return extends Codeable {
+    /**
+     * Return code.
+     */
+    getCode(): string;
+    /**
+     * Return code.
+     */
+    setCode(code: string): void;
+    /**
+     * Return message.
+     */
+    getMessage(): string;
+    /**
+     * Return message.
+     */
+    setMessage(message: string): void;
+    /**
+     * Return cause.
+     */
+    getCause(): Stacktrace | undefined;
+    /**
+     * Return cause.
+     */
+    setCause(cause: Stacktrace): void;
+    /**
+     * Return content.
+     */
+    getContent(): any;
+    /**
+     * Return content.
+     */
+    setContent(content: any): void;
+}
+export declare class Argument {
+    index: number;
+    name: string;
+    kind: any;
+    constructor(index: number, name: string, kind: any);
+}
+export declare class MethodInspector implements Inspector {
+    private readonly kind;
+    private readonly name;
+    private readonly method;
+    constructor(kind: any, name: string, method: any);
+    getAnnotation<T>(macro: Type<T>): T | undefined;
+    getName(): string;
+    getParameters(): Argument[];
+    getType<T>(): Type<T>;
+    getReturnType(): Types;
+    getExecutable(): any;
+    getSymbol(): string;
+    invoke(target: any, args: any[]): any;
+}
+export declare class Dynamic {
+    private static proxies;
+    private static inspectors;
+    static newProxyInstance<T>(kind: Type<T>, h: InvocationHandler): T;
+    static getMethods<T>(kind: Type<T>): Inspector[];
+}

package/dist/macro/loader.d.ts

@@ -0,0 +1,15 @@
+import { Type } from './ark';
+export declare class ServiceLoader<T> {
+    private static loaders;
+    static load<T>(kind: Type<T>): ServiceLoader<T>;
+    private providers;
+    private readonly spi;
+    private readonly fist;
+    constructor(spi: Type<T>);
+    defaultName(): string;
+    getDefault(): T;
+    get(name: string): T;
+    want(name: string): T | null;
+    list(): T[];
+    private getInstances;
+}