@firmer/mesh 0.0.1

package/dist/mpc/compiler.d.ts

@@ -0,0 +1,23 @@
+import { Class, Inspector, Parameter, Return } from '../macro';
+export declare abstract class Compiler {
+    /**
+     * Get the parameter class type.
+     */
+    abstract intype(method: Inspector): Class<Parameter>;
+    /**
+     * Get the return class type.
+     */
+    abstract retype(method: Inspector): Class<Return>;
+    /**
+     * Compile source code.
+     */
+    abstract compile(code: string, name: string): any;
+}
+export declare function returnType<T extends (...args: any) => any>(fn: T): T;
+export declare class TSCompiler extends Compiler {
+    private static readonly parameters;
+    private static readonly returns;
+    compile(code: string, name: string): any;
+    intype(method: Inspector): Class<Parameter>;
+    retype(method: Inspector): Class<Return>;
+}

package/dist/mpc/consumer.d.ts

@@ -0,0 +1,28 @@
+import { Reference } from '../types';
+import { Context } from '../psi';
+import { Execution } from '.';
+export declare abstract class Consumer {
+    static HTTP: string;
+    static GRPC: string;
+    static TCP: string;
+    static MQTT: string;
+    /**
+     * Start the mesh broker.
+     */
+    abstract start(): void;
+    /**
+     * Stop the mesh broker.
+     */
+    abstract close(): void;
+    /**
+     * Consume the input payload.
+     *
+     * @param ctx       Call context.
+     * @param address   Remote address.
+     * @param urn       Actual uniform resource domain name.
+     * @param execution Service reference.
+     * @param inbound   Input arguments.
+     * @return Output payload
+     */
+    abstract consume(ctx: Context, address: string, urn: string, execution: Execution<Reference>, inbound: Uint8Array): Promise<Uint8Array>;
+}

package/dist/mpc/consumer_filter.d.ts

@@ -0,0 +1,6 @@
+import { Filter } from './filter';
+import { Context } from '../psi';
+import { Invocation, Invoker } from './invoker';
+export declare class ConsumerFilter extends Filter {
+    invoke(ctx: Context, invoker: Invoker<any>, invocation: Invocation): Promise<any>;
+}

package/dist/mpc/context.d.ts

@@ -0,0 +1,33 @@
+import { Context, ContextProvider, Deque, Key } from '../psi';
+import { Location, Principal } from '../types';
+export declare class MeshContext extends Context {
+    private traceId;
+    private spanId;
+    private timestamp;
+    private runMode;
+    private urn;
+    private consumer;
+    private calls;
+    private attachments;
+    private attributes;
+    private principals;
+    static create(): Context;
+    getAttachments(): Map<string, string>;
+    getAttribute<T>(key: Key<T>): any;
+    getAttributes(): Map<string, any>;
+    getConsumer(ctc: Context): Location;
+    getPrincipals(): Deque<Principal>;
+    getProvider(ctx: Context): Location;
+    getRunMode(): number;
+    getSpanId(): string;
+    getTimestamp(): number;
+    getTraceId(): string;
+    getUrn(): string;
+    setAttribute<T>(key: Key<T>, value: any): void;
+    resume(): Context;
+    rewriteContext(ctx: Context): void;
+    rewriteURN(urn: string): void;
+}
+export declare class MeshContextProvider extends ContextProvider {
+    context(): Context;
+}

package/dist/mpc/eden.d.ts

@@ -0,0 +1,44 @@
+import { Inspector, Type } from '../macro';
+import { Context } from '../psi';
+import { Reference, Service } from '../types';
+import { Execution } from './execution';
+export declare abstract class Eden {
+    /**
+     * Define the reference object.
+     * @param ctx
+     * @param metadata
+     * @param reference
+     */
+    abstract define(ctx: Context, metadata: any, reference: Type<any>): any;
+    /**
+     * Refer the service reference by method.
+     * @param ctx
+     * @param metadata
+     * @param reference
+     * @param method
+     */
+    abstract refer(ctx: Context, metadata: any, reference: Type<any>, method: Inspector): Execution<Reference>;
+    /**
+     * Store the service object.
+     * @param ctx
+     * @param kind
+     * @param service
+     */
+    abstract store(ctx: Context, kind: Type<any>, service: any): void;
+    /**
+     * Infer the reference service by domain.
+     * @param ctx
+     * @param urn
+     */
+    abstract infer(ctx: Context, urn: string): Execution<Service>;
+    /**
+     * Get all reference types.
+     * @param ctx
+     */
+    abstract referTypes(ctx: Context): Type<any>[];
+    /**
+     * Get all service types.
+     * @param ctx
+     */
+    abstract inferTypes(ctx: Context): Type<any>[];
+}

package/dist/mpc/execution.d.ts

@@ -0,0 +1,74 @@
+import { Context } from '../psi';
+import { Argument, Stacktrace, Class, Inspector, Parameter, Return, Type, Types } from '../macro';
+import { URN } from './urn';
+export interface Execution<T> {
+    /**
+     * Execution schema.
+     * @param ctx
+     */
+    schema(ctx: Context): T;
+    /**
+     * Inspect execution.
+     * @param ctx
+     */
+    inspect(ctx: Context): Inspector;
+    /**
+     * Execution input type.
+     */
+    intype(ctx: Context): Class<Parameter>;
+    /**
+     * Execution output return type.
+     */
+    retype(ctx: Context): Class<Return>;
+    /**
+     * Reflect input type.
+     * @param ctx
+     */
+    inflect(ctx: Context): Parameter;
+    /**
+     * Reflect output return type.
+     * @param ctx
+     */
+    reflect(ctx: Context): Return;
+}
+export declare class GenericExecution implements Execution<any> {
+    private readonly inspector;
+    private readonly reference;
+    private readonly service;
+    constructor(ctx: Context, urn: URN);
+    inflect(ctx: Context): Parameter;
+    inspect(ctx: Context): Inspector;
+    intype(ctx: Context): Class<Parameter>;
+    reflect(ctx: Context): Return;
+    retype(ctx: Context): Class<Return>;
+    schema(ctx: Context): any;
+}
+export declare class GenericInspector implements Inspector {
+    private readonly urn;
+    constructor(urn: URN);
+    getType(): Type<any>;
+    getAnnotation<T>(kind: Type<T>): T | undefined;
+    getName(): string;
+    getParameters(): Argument[];
+    getReturnType(): Types;
+    getExecutable(): () => void;
+    getSymbol(): string;
+    invoke(target: any, args: any[]): any;
+}
+export declare class GenericParameters extends Map<string, any> implements Parameter {
+    map(): Map<string, any>;
+    getArguments(): any[];
+    getAttachments(): Map<string, string>;
+    setArguments(args: any[]): void;
+    setAttachments(attachments: Map<string, string>): void;
+}
+export declare class GenericReturns extends Map<string, any> implements Return {
+    getCause(): Stacktrace | undefined;
+    getCode(): string;
+    getContent(): any;
+    getMessage(): string;
+    setCause(cause: Stacktrace): void;
+    setCode(code: string): void;
+    setContent(content: any): void;
+    setMessage(message: string): void;
+}

package/dist/mpc/filter.d.ts

@@ -0,0 +1,19 @@
+import { Invocation, Invoker } from './invoker';
+import { Context } from '../psi';
+export declare const PROVIDER: string;
+export declare const CONSUMER: string;
+export declare abstract class Filter {
+    /**
+     * Invoke the next filter.
+     * @param ctx
+     * @param invoker
+     * @param invocation
+     */
+    abstract invoke(ctx: Context, invoker: Invoker<any>, invocation: Invocation): Promise<any>;
+}
+/**
+ * Composite the filter spi providers as a invoker.
+ * @param invoker
+ * @param pattern
+ */
+export declare function composite(invoker: Invoker<any>, pattern: string): Invoker<any>;

package/dist/mpc/hook.d.ts

@@ -0,0 +1,23 @@
+import { Dict, globalPtr } from '../macro';
+import { Filter } from './filter';
+import { Context } from '../psi';
+import { Invocation, Invoker } from './invoker';
+import { Codeable } from '../cause';
+export interface MeshDescriptor {
+    beforeHooks: Dict<string, (ctx: Context, invocation: Invocation) => void>;
+    successHooks: Dict<string, (ctx: Context, invocation: Invocation, r: any) => void>;
+    failureHooks: Dict<string, (ctx: Context, invocation: Invocation, e: Codeable) => void>;
+}
+declare class Hooks {
+    onBefore(name: string, hook: (ctx: Context, invocation: Invocation) => void): void;
+    onSuccess(name: string, hook: (ctx: Context, invocation: Invocation, r: any) => void): void;
+    onFailure(name: string, hook: (ctx: Context, invocation: Invocation, e: Codeable) => void): void;
+    before(): Dict<string, (ctx: Context, invocation: Invocation) => void>;
+    success(): Dict<string, (ctx: Context, invocation: Invocation, r: any) => void>;
+    failure(): Dict<string, (ctx: Context, invocation: Invocation, r: Codeable) => void>;
+}
+declare const Hook: Hooks;
+export declare class HookFilter extends Filter {
+    invoke(ctx: Context, invoker: Invoker<any>, invocation: Invocation): Promise<any>;
+}
+export { Hook, globalPtr };

package/dist/mpc/index.d.ts

@@ -0,0 +1,16 @@
+export * from './compiler';
+export * from './consumer';
+export * from './context';
+export * from './eden';
+export * from './execution';
+export * from './filter';
+export * from './hook';
+export * from './invoker';
+export * from './mesh';
+export * from './mesh_eden';
+export * from './mock';
+export * from './provider';
+export * from './proxy';
+export * from './reference';
+export * from './service';
+export * from './urn';

package/dist/mpc/invoker.d.ts

@@ -0,0 +1,57 @@
+import { Context } from '../psi';
+import { Inspector, Parameter } from '../macro';
+import { Execution } from './execution';
+export interface Invoker<T> {
+    run(ctx: Context, invocation: Invocation): Promise<any>;
+}
+export interface Invocation {
+    /**
+     * Get the delegate target object.
+     * @param ctx
+     */
+    getProxy(ctx: Context): Invoker<any>;
+    /**
+     * Get the invocation inspector.
+     * @param ctx
+     */
+    getInspector(ctx: Context): Inspector;
+    /**
+     * Invoke parameters. include arguments and parameters.
+     * @param ctx
+     */
+    getParameters(ctx: Context): Parameter;
+    /**
+     * Invoke parameters.
+     * @param ctx
+     */
+    getArguments(ctx: Context): any[];
+    /**
+     * Get the attachments. The attributes will be serialized.
+     * @param ctx
+     */
+    getAttachments(ctx: Context): Map<string, string>;
+    /**
+     * Get the invocation execution.
+     * @param ctx
+     */
+    getExecution<V>(ctx: Context): Execution<V>;
+    /**
+     * Is the method return future.
+     * @param ctx
+     */
+    isAsync(ctx: Context): boolean;
+}
+export declare class ServiceInvocation<T> implements Invocation {
+    private readonly proxy;
+    private readonly inspector;
+    private readonly parameters;
+    private readonly execution;
+    constructor(proxy: Invoker<T>, inspector: Inspector, parameters: Parameter, execution: Execution<any>);
+    getArguments(ctx: Context): any[];
+    getAttachments(ctx: Context): Map<string, string>;
+    getExecution<V>(ctx: Context): Execution<V>;
+    getInspector(ctx: Context): Inspector;
+    getParameters(ctx: Context): Parameter;
+    getProxy(ctx: Context): Invoker<any>;
+    isAsync(ctx: Context): boolean;
+}

package/dist/mpc/mesh.d.ts

@@ -0,0 +1,42 @@
+import { Key } from '../psi';
+import { Invocation } from './invoker';
+export declare class Mesh {
+    /**
+     * Mesh mpc remote address.
+     */
+    static REMOTE: Key<string>;
+    /**
+     * Remote app name.
+     */
+    static REMOTE_NAME: Key<string>;
+    /**
+     * Mesh invocation attributes.
+     */
+    static INVOCATION: Key<Invocation>;
+    /**
+     * Mesh invoke mpi name attributes.
+     */
+    static UNAME: Key<string>;
+}
+declare class MeshFlag {
+    code: string;
+    name: string;
+    constructor(code: string, name: string);
+}
+export declare class MeshFlags {
+    static HTTP: MeshFlag;
+    static GRPC: MeshFlag;
+    static MQTT: MeshFlag;
+    static TCP: MeshFlag;
+    static JSON: MeshFlag;
+    static PROTOBUF: MeshFlag;
+    static XML: MeshFlag;
+    static THRIFT: MeshFlag;
+    static YAML: MeshFlag;
+    private static PROTO;
+    private static CODEC;
+    static ofProto(code: string): MeshFlag;
+    static ofCodec(code: string): MeshFlag;
+    static ofName(name: string): MeshFlag;
+}
+export {};

package/dist/mpc/mesh_eden.d.ts

@@ -0,0 +1,25 @@
+import { Eden } from './eden';
+import { Context } from '../psi';
+import { Inspector, Type } from '../macro';
+import { Reference, Service } from '../types';
+import { Execution } from './execution';
+export declare class MeshEden extends Eden {
+    private providers;
+    private consumers;
+    private indies;
+    private services;
+    private references;
+    define(ctx: Context, metadata: any, reference: Type<any>): any;
+    store(ctx: Context, kind: Type<any>, service: any): void;
+    infer(ctx: Context, urn: string): Execution<Service>;
+    refer(ctx: Context, metadata: any, reference: Type<any>, method: Inspector): Execution<Reference>;
+    inferTypes(ctx: Context): Type<any>[];
+    referTypes(ctx: Context): Type<any>[];
+    private makeConsumer;
+    private makeMethodAsReference;
+    private getURN;
+    private getURNFlag;
+    private getMethods;
+    private getEnviron;
+    private makeServiceExecution;
+}

package/dist/mpc/mock.d.ts

@@ -0,0 +1,7 @@
+import { Filter } from './filter';
+import { Context } from '../psi';
+import { Invocation, Invoker } from './invoker';
+export declare const Mock = "mock";
+export declare class MockFilter extends Filter {
+    invoke(ctx: Context, invoker: Invoker<any>, invocation: Invocation): Promise<any>;
+}

package/dist/mpc/provider.d.ts

@@ -0,0 +1,10 @@
+export declare abstract class Provider {
+    /**
+     * Start the mesh broker.
+     */
+    abstract start(): void;
+    /**
+     * Stop the mesh broker.
+     */
+    abstract close(): void;
+}

package/dist/mpc/proxy.d.ts

@@ -0,0 +1,6 @@
+import { MethodProxy, Type } from '../macro';
+export declare class ServiceProxy extends MethodProxy {
+    proxy<T>(kind: Type<T>): T;
+    static proxy<T>(kind: Type<T>): T;
+    static doProxy<T>(kind: Type<T>, metadata: any): any;
+}

package/dist/mpc/reference.d.ts

@@ -0,0 +1,21 @@
+import { Inspector, InvocationHandler } from '../macro';
+import { Invocation, Invoker } from './invoker';
+import { Context } from '../psi';
+import { Reference } from '../types';
+import { Codec } from '../codec';
+import { Execution } from './execution';
+export declare class ReferenceInvokeHandler<T extends object> implements Invoker<any>, InvocationHandler {
+    private readonly macro;
+    private readonly invoker;
+    constructor(macro: any);
+    context(args: any[]): Context;
+    invoke(proxy: any, method: Inspector, args: any[]): any;
+    run(ctx: Context, invocation: Invocation): Promise<any>;
+    deserialize(ctx: Context, execution: Execution<Reference>, codec: Codec, future: Uint8Array): Promise<any>;
+    referExecution(ctx: Context, inspector: Inspector): Execution<Reference>;
+    /**
+     * Rewrite the urn by execution context.
+     */
+    private rewriteURN;
+    private rewriteAddress;
+}

package/dist/mpc/service.d.ts

@@ -0,0 +1,7 @@
+import { Invocation, Invoker } from './invoker';
+import { Context } from '../psi';
+export declare class ServiceInvokeHandler implements Invoker<any> {
+    private invoker;
+    constructor(service: any);
+    run(ctx: Context, invocation: Invocation): Promise<any>;
+}

package/dist/mpc/urn.d.ts

@@ -0,0 +1,32 @@
+export declare class URN {
+    static CN: string;
+    static MESH_DOMAIN: string;
+    static LocalMDC: string;
+    domain: string;
+    mdc: string;
+    flag: URNFlag;
+    name: string;
+    static from(urn: string): URN;
+    static urn(name: string): string;
+    toString(): string;
+    private asArray;
+    matchName(name: string): boolean;
+    resetFlag(proto: string, codec: string): URN;
+}
+export declare class URNFlag {
+    v: string;
+    proto: string;
+    codec: string;
+    version: string;
+    zone: string;
+    cluster: string;
+    cell: string;
+    group: string;
+    address: string;
+    port: string;
+    static from(value: string): URNFlag;
+    toString(): string;
+    private padding;
+    private paddingChain;
+    private static reduce;
+}

package/dist/psi/builtin.d.ts

@@ -0,0 +1,49 @@
+import { Context } from './context';
+import { Versions } from '../types';
+export declare abstract class Builtin {
+    /**
+     * Doc export the documents.
+     *
+     * Parameters:
+     * name      - mesh.name
+     * formatter - document formatter
+     * formatted - document
+     * Returns:
+     * formatted document
+     */
+    doc(name: string, formatter: string, ctx?: Context): Promise<string>;
+    /**
+     * Version will get the builtin application version.
+     */
+    version(ctx?: Context): Promise<Versions>;
+    /**
+     * Debug set the application log level.
+     */
+    debug(features: Record<string, string>, ctx?: Context): Promise<void>;
+    /**
+     * Stats will collect health check stats.
+     */
+    stats(features: string[], ctx?: Context): Promise<Record<string, string>>;
+    /**
+     * Fallback is fallback service
+     */
+    fallback(ctx?: Context): Promise<void>;
+    /**
+     * Dump the application data.
+     */
+    dump(names: string[], ctx?: Context): Promise<Record<string, string>>;
+}
+export declare abstract class Hodor {
+    /**
+     * Stats collect the system, application, process or thread status etc.
+     */
+    stats(features: string[], ctx?: Context): Promise<Record<string, string>>;
+    /**
+     * Debug set the debug features.
+     */
+    debug(features: Record<string, string>, ctx?: Context): Promise<void>;
+    /**
+     * Dump the application data.
+     */
+    dump(ctx?: Context): Promise<string>;
+}

package/dist/psi/cache.d.ts

@@ -0,0 +1,44 @@
+import { Context } from './context';
+import { CacheBody } from '../types';
+export declare abstract class Cache {
+    /**
+     * Get the value from cache.
+     */
+    get(key: string, ctx?: Context): Promise<CacheBody>;
+    /**
+     * Put the value to cache.
+     */
+    put(cell: CacheBody, ctx?: Context): Promise<void>;
+    /**
+     * Remove the cache value.
+     */
+    remove(key: string, ctx?: Context): Promise<void>;
+    /**
+     * Incr the cache of expire time.
+     */
+    incr(key: string, value: number, ctx?: Context): Promise<number>;
+    /**
+     * Decr the cache of expire time.
+     */
+    decr(key: string, value: number, ctx?: Context): Promise<number>;
+    /**
+     * Keys the cache key set.
+     */
+    keys(pattern: string, ctx?: Context): Promise<string[]>;
+    /**
+     * HGet get value in hash
+     */
+    hget(key: string, name: string, ctx?: Context): Promise<CacheBody>;
+    /**
+     * HSet put value in hash
+     */
+    hset(key: string, cell: CacheBody, ctx?: Context): Promise<void>;
+    /**
+     * HDel put value in hash
+     */
+    hdel(key: string, name: string, ctx?: Context): Promise<void>;
+    /**
+     * HKeys get the hash keys
+     */
+    hkeys(key: string, ctx?: Context): Promise<string[]>;
+}

package/dist/psi/cipher.d.ts

@@ -0,0 +1,73 @@
+import { Context } from './context';
+import { CipherEntity, CipherHello, CipherKey, CipherKeygen, CipherObject, CipherRegen, CipherSuite, CipherTxEntity, Keys, Page, Paging } from '../types';
+export declare abstract class CipherEconomy {
+    /**
+     * Handshake negotiate multiparty cipher keys.
+     *
+     * Parameters:
+     * - hello: hello
+     * Returns:
+     * - string cipher group
+     */
+    handshake(hello: CipherHello, ctx?: Context): Promise<string>;
+    /**
+     * Collect cipher objects with group. Asyncable can be invoked by multi times.
+     *
+     * Parameters:
+     * - obj: obj
+     * Returns:
+     * - int 1 for success, 0 for failed
+     */
+    collect(obj: CipherObject, ctx?: Context): Promise<number>;
+    /**
+     * Serve will Encrypt or Anonymize
+     */
+    serve(suite: string, ctx?: Context): Promise<string>;
+    /**
+     * Deposit cipher object deposit
+     */
+    deposit(rco: CipherObject, ctx?: Context): Promise<string>;
+    /**
+     * Objects cipher object index
+     */
+    objects(index: Paging, ctx?: Context): Promise<Page<CipherObject>>;
+    /**
+     * Keys key index
+     */
+    keys(idx: Paging, ctx?: Context): Promise<Page<Keys>>;
+    /**
+     * Invoke
+     */
+    invoke(index: Paging, ctx?: Context): Promise<Uint8Array>;
+}
+export declare abstract class CipherProvider {
+    /**
+     * Suite
+     */
+    suite(hello: CipherHello, ctx?: Context): Promise<CipherSuite>;
+    /**
+     * Keygen
+     */
+    keygen(keygen: CipherKeygen, ctx?: Context): Promise<CipherKey>;
+    /**
+     * Regen
+     */
+    regen(keygen: CipherRegen, ctx?: Context): Promise<CipherKey>;
+    /**
+     * Encode
+     */
+    encode(explain: CipherEntity, ctx?: Context): Promise<Uint8Array>;
+    /**
+     * Decode
+     */
+    decode(cipher: CipherEntity, ctx?: Context): Promise<Uint8Array>;
+    /**
+     * Recode
+     */
+    recode(cipher: CipherTxEntity, ctx?: Context): Promise<Uint8Array>;
+}
+export declare abstract class ObjectProvider {
+    /**
+     */
+    serve(ctx?: Context): Promise<string>;
+}

package/dist/psi/cluster.d.ts

@@ -0,0 +1,11 @@
+import { Context } from './context';
+export declare abstract class Cluster {
+    /**
+     * Election will election leader of instances.
+     */
+    election(buff: Uint8Array, ctx?: Context): Promise<Uint8Array>;
+    /**
+     * IsLeader if same level.
+     */
+    isLeader(ctx?: Context): Promise<boolean>;
+}