@firmer/mesh 0.0.1

package/dist/psi/commerce.d.ts

@@ -0,0 +1,20 @@
+import { Context } from './context';
+import { CommerceEnviron, CommerceLicense, License } from '../types';
+export declare abstract class Commercialize {
+    /**
+     * Sign license, only glab has permission to sign.
+     */
+    sign(lsr: License, ctx?: Context): Promise<CommerceLicense>;
+    /**
+     * History list the sign license in history, the latest is the first index.
+     */
+    history(instId: string, ctx?: Context): Promise<CommerceLicense[]>;
+    /**
+     * Issued mesh node identity.
+     */
+    issued(name: string, kind: string, cname: string, ctx?: Context): Promise<CommerceEnviron>;
+    /**
+     * Dump the node identity.
+     */
+    dump(nodeId: string, ctx?: Context): Promise<CommerceEnviron[]>;
+}

package/dist/psi/context.d.ts

@@ -0,0 +1,148 @@
+import { Location, Principal } from '../types/principal';
+export declare class RunMode {
+    /**
+     * Routine 正常模式
+     */
+    static readonly Routine: RunMode;
+    /**
+     * Perform 评测模式
+     */
+    static readonly Perform: RunMode;
+    /**
+     * Defense 高防模式
+     */
+    static readonly Defense: RunMode;
+    /**
+     * Debug 调试模式
+     */
+    static readonly Debug: RunMode;
+    /**
+     * LoadTest 压测模式
+     */
+    static readonly LoadTest: RunMode;
+    /**
+     * Mock Mock模式
+     */
+    static readonly Mock: RunMode;
+    private readonly v;
+    constructor(v: number);
+    /**
+     * match run mode or else.
+     */
+    matches(r: number): boolean;
+}
+export declare class Key<T> {
+    name: string;
+    constructor(name: string);
+}
+export declare class Deque<T> extends Array {
+    peek(): T | undefined;
+}
+export declare abstract class Context {
+    /**
+     * GetTraceId the request trace id.
+     */
+    abstract getTraceId(): string;
+    /**
+     * GetSpanId the request span id.
+     */
+    abstract getSpanId(): string;
+    /**
+     * getTimestamp the request create time.
+     */
+    abstract getTimestamp(): number;
+    /**
+     * getRunMode the request run mode. {@link RunMode}
+     */
+    abstract getRunMode(): number;
+    /**
+     * getUrn mesh resource uniform name. Like: create.tenant.omega.json.http2.lx000001.mpi.3344.tech
+     */
+    abstract getUrn(): string;
+    /**
+     * getConsumer the consumer network principal.
+     */
+    abstract getConsumer(ctc: Context): Location;
+    /**
+     * getProvider the provider network principal.
+     * @param ctx
+     */
+    abstract getProvider(ctx: Context): Location;
+    /**
+     * getAttachments Dispatch attachments.
+     */
+    abstract getAttachments(): Map<string, string>;
+    /**
+     * getPrincipals Get the mpc broadcast network principals.
+     */
+    abstract getPrincipals(): Deque<Principal>;
+    /**
+     * getAttributes like getAttachments, but attribute wont be transfer in invoke chain.
+     */
+    abstract getAttributes(): Map<string, any>;
+    /**
+     * getAttribute like getAttachments, but attribute wont be transfer in invoke chain.
+     */
+    abstract getAttribute<T>(key: Key<T>): any;
+    /**
+     * setAttribute Like putAttachments, but attribute won't be transfer in invoke chain.
+     */
+    abstract setAttribute<T>(key: Key<T>, value: any): void;
+    /**
+     * rewriteURN rewrite the urn.
+     */
+    abstract rewriteURN(urn: string): void;
+    /**
+     * rewriteContext rewrite the context by another context.
+     */
+    abstract rewriteContext(ctx: Context): void;
+    /**
+     * resume will open a new context.
+     */
+    abstract resume(): Context;
+}
+/**
+ * https://www.rfc-editor.org/rfc/rfc7540#section-8.1.2
+ */
+export declare class Header {
+    static MESH_TRACE_ID: Header;
+    static MESH_SPAN_ID: Header;
+    static MESH_TIMESTAMP: Header;
+    static MESH_RUN_MODE: Header;
+    static MESH_CONSUMER: Header;
+    static MESH_PROVIDER: Header;
+    static MESH_URN: Header;
+    static MESH_FROM_INST_ID: Header;
+    static MESH_FROM_NODE_ID: Header;
+    static MESH_INCOMING_HOST: Header;
+    static MESH_OUTGOING_HOST: Header;
+    static MESH_INCOMING_PROXY: Header;
+    static MESH_OUTGOING_PROXY: Header;
+    static MESH_SUBSET: Header;
+    static MESH_SESSION_ID: Header;
+    static MESH_VERSION: Header;
+    static MESH_TIMEOUT: Header;
+    static MESH_PTP_VERSION: Header;
+    static MESH_PTP_TPC: Header;
+    static MESH_PTP_TRACE_ID: Header;
+    static MESH_PTP_TOKEN: Header;
+    static MESH_PTP_SOURCE_NODE_ID: Header;
+    static MESH_PTP_TARGET_NODE_ID: Header;
+    static MESH_PTP_SOURCE_INST_ID: Header;
+    static MESH_PTP_TARGET_INST_ID: Header;
+    static MESH_PTP_SESSION_ID: Header;
+    private readonly key;
+    constructor(key: string);
+    get(ctx: Context): string;
+    set(ctx: Context, value: string): void;
+}
+export declare abstract class ContextProvider {
+    /**
+     * New mpc context.
+     */
+    abstract context(): Context;
+}
+/**
+ * New mpc context.
+ */
+export declare function context(): Context;

package/dist/psi/cryptor.d.ts

@@ -0,0 +1,23 @@
+import { Context } from './context';
+export declare abstract class Cryptor {
+    /**
+     * Encrypt binary to encrypted binary.
+     */
+    encrypt(buf: Uint8Array, keys: Record<string, Uint8Array>, ctx?: Context): Promise<Uint8Array>;
+    /**
+     * Decrypt binary to decrypted binary.
+     */
+    decrypt(buf: Uint8Array, keys: Record<string, Uint8Array>, ctx?: Context): Promise<Uint8Array>;
+    /**
+     * Hash compute the hash value.
+     */
+    hash(buf: Uint8Array, keys: Record<string, Uint8Array>, ctx?: Context): Promise<Uint8Array>;
+    /**
+     * Sign compute the signature value.
+     */
+    sign(buf: Uint8Array, keys: Record<string, Uint8Array>, ctx?: Context): Promise<Uint8Array>;
+    /**
+     * Verify the signature value.
+     */
+    verify(buf: Uint8Array, keys: Record<string, Uint8Array>, ctx?: Context): Promise<boolean>;
+}

package/dist/psi/datahouse.d.ts

@@ -0,0 +1,24 @@
+import { Context } from './context';
+import { Document, Page, Paging } from '../types';
+export declare abstract class DataHouse {
+    /**
+     * Writes
+     */
+    writes(docs: Document[], ctx?: Context): Promise<void>;
+    /**
+     * Write
+     */
+    write(doc: Document, ctx?: Context): Promise<void>;
+    /**
+     * Read
+     */
+    read(index: Paging, ctx?: Context): Promise<Page<any>>;
+    /**
+     * Indies
+     */
+    indies(index: Paging, ctx?: Context): Promise<Page<any>>;
+    /**
+     * Tables
+     */
+    tables(index: Paging, ctx?: Context): Promise<Page<any>>;
+}

package/dist/psi/dispatcher.d.ts

@@ -0,0 +1,13 @@
+import { Context } from './context';
+export declare abstract class Dispatcher {
+    /**
+     * Invoke with fewer returns
+     * In multi returns, it will discard multi returns
+     */
+    invoke(urn: string, param: Record<string, any>, ctx?: Context): Promise<any>;
+    /**
+     * Invoke0 with fewer returns in generic mode
+     * In multi returns, it will discard multi returns
+     */
+    invoke0(urn: string, param: any, ctx?: Context): Promise<any>;
+}

package/dist/psi/endpoint.d.ts

@@ -0,0 +1,14 @@
+import { Context } from './context';
+export declare abstract class Endpoint {
+    /**
+     * Fuzzy call with generic param
+     * In multi returns, it's an array.
+     */
+    fuzzy(buff: Uint8Array, ctx?: Context): Promise<Uint8Array>;
+}
+export declare abstract class EndpointSticker<I, O> {
+    /**
+     * Stick with generic param
+     */
+    stick(varg: I, ctx?: Context): Promise<O>;
+}

package/dist/psi/evaluator.d.ts

@@ -0,0 +1,20 @@
+import { Context } from './context';
+import { Page, Paging, Script } from '../types';
+export declare abstract class Evaluator {
+    /**
+     * Compile the named rule.
+     */
+    compile(script: Script, ctx?: Context): Promise<string>;
+    /**
+     * Exec the script with name.
+     */
+    exec(code: string, args: Record<string, string>, dft: string, ctx?: Context): Promise<string>;
+    /**
+     * Dump the scripts.
+     */
+    dump(feature: Record<string, string>, ctx?: Context): Promise<Script[]>;
+    /**
+     * Index the scripts.
+     */
+    index(index: Paging, ctx?: Context): Promise<Page<Script>>;
+}

package/dist/psi/graph.d.ts

@@ -0,0 +1,11 @@
+import { Context } from './context';
+export declare abstract class Graph {
+    /**
+     * Query with cypher.
+     */
+    query(expr: string, args: Record<string, any>, ctx?: Context): Promise<Record<string, any>[]>;
+    /**
+     * Exec cypher.
+     */
+    exec(expr: string, args: Record<string, any>, ctx?: Context): Promise<void>;
+}

package/dist/psi/index.d.ts

@@ -0,0 +1,29 @@
+export * from './builtin';
+export * from './cache';
+export * from './cipher';
+export * from './cluster';
+export * from './commerce';
+export * from './context';
+export * from './cryptor';
+export * from './datahouse';
+export * from './dispatcher';
+export * from './endpoint';
+export * from './evaluator';
+export * from './graph';
+export * from './kms';
+export * from './kv';
+export * from './licenser';
+export * from './locker';
+export * from './network';
+export * from './pipeline';
+export * from './publisher';
+export * from './registry';
+export * from './routable';
+export * from './savepoint';
+export * from './scheduler';
+export * from './sequence';
+export * from './subscriber';
+export * from './tokenizer';
+export * from './transport';
+export * from './vfs';
+export * from './workflow';

package/dist/psi/kms.d.ts

@@ -0,0 +1,20 @@
+import { Context } from './context';
+import { Environ, KeyCsr, Keys } from '../types';
+export declare abstract class KMS {
+    /**
+     * Reset will override the keystore environ.
+     */
+    reset(env: Environ, ctx?: Context): Promise<void>;
+    /**
+     * Environ will return the keystore environ.
+     */
+    environ(ctx?: Context): Promise<Environ>;
+    /**
+     * List will return the keystore environ.
+     */
+    list(cno: string, ctx?: Context): Promise<Keys[]>;
+    /**
+     * Issue will apply the certification.
+     */
+    issue(csr: KeyCsr, ctx?: Context): Promise<Keys[]>;
+}

package/dist/psi/kv.d.ts

@@ -0,0 +1,24 @@
+import { Context } from './context';
+import { Body, Entry, Page, Paging } from '../types';
+export declare abstract class KV {
+    /**
+     * Get the value from kv store.
+     */
+    get(key: string, ctx?: Context): Promise<Body>;
+    /**
+     * Put the value to kv store.
+     */
+    put(key: string, value: Body, ctx?: Context): Promise<void>;
+    /**
+     * Remove the kv store.
+     */
+    remove(key: string, ctx?: Context): Promise<void>;
+    /**
+     * Keys with the pattern of kv store.
+     */
+    keys(pattern: string, ctx?: Context): Promise<string[]>;
+    /**
+     * Index the kv for webui
+     */
+    index(index: Paging, ctx?: Context): Promise<Page<Entry>>;
+}

package/dist/psi/licenser.d.ts

@@ -0,0 +1,24 @@
+import { Context } from './context';
+import { License } from '../types';
+export declare abstract class Licenser {
+    /**
+     * Imports the licenses.
+     */
+    imports(license: string, ctx?: Context): Promise<void>;
+    /**
+     * Exports the licenses.
+     */
+    exports(ctx?: Context): Promise<string>;
+    /**
+     * Explain the license.
+     */
+    explain(ctx?: Context): Promise<License>;
+    /**
+     * Verify the license.
+     */
+    verify(ctx?: Context): Promise<number>;
+    /**
+     * Features is license features.
+     */
+    features(ctx?: Context): Promise<Record<string, string>>;
+}

package/dist/psi/locker.d.ts

@@ -0,0 +1,19 @@
+import { Context } from './context';
+export declare abstract class Locker {
+    /**
+     * Lock create write lock.
+     */
+    lock(rid: string, timeout: number, ctx?: Context): Promise<boolean>;
+    /**
+     * Unlock release write lock.
+     */
+    unlock(rid: string, ctx?: Context): Promise<void>;
+    /**
+     * ReadLock create read lock.
+     */
+    readLock(rid: string, timeout: number, ctx?: Context): Promise<boolean>;
+    /**
+     * ReadUnlock release read lock.
+     */
+    readUnlock(rid: string, ctx?: Context): Promise<void>;
+}

package/dist/psi/network.d.ts

@@ -0,0 +1,49 @@
+import { Context } from './context';
+import { Environ, Page, Paging, Route, Versions } from '../types';
+export declare abstract class Network {
+    /**
+     * Environ Get the meth network environment fixed information.
+     */
+    environ(ctx?: Context): Promise<Environ>;
+    /**
+     * Accessible Check the mesh network is accessible.
+     */
+    accessible(route: Route, ctx?: Context): Promise<boolean>;
+    /**
+     * Refresh the routes to mesh network.
+     */
+    refresh(routes: Route[], ctx?: Context): Promise<void>;
+    /**
+     * Route the network edge route.
+     */
+    route(mdc: string, ctx?: Context): Promise<Route>;
+    /**
+     * Routes the network edge routes.
+     */
+    routes(ctx?: Context): Promise<Route[]>;
+    /**
+     * Disable the network
+     */
+    disable(mdc: string, ctx?: Context): Promise<void>;
+    /**
+     * Enable the network
+     */
+    enable(mdc: string, ctx?: Context): Promise<void>;
+    /**
+     * Index the network edges
+     */
+    index(index: Paging, ctx?: Context): Promise<Page<Route>>;
+    /**
+     * Version
+     * Network environment version.
+     */
+    version(mdc: string, ctx?: Context): Promise<Versions>;
+    /**
+     * Exports the weave certificate.
+     */
+    exports(mdc: string, ctx?: Context): Promise<string>;
+    /**
+     * Imports the weave certificate.
+     */
+    imports(crt: string, ctx?: Context): Promise<void>;
+}

package/dist/psi/pipeline.d.ts

@@ -0,0 +1,28 @@
+import { Context } from './context';
+export declare abstract class Pipeline {
+    /**
+     * Peek
+     * Retrieves, but does not remove, the head of this queue,
+     * or returns None if this queue is empty.
+     */
+    peek(topic: string, ctx?: Context): Promise<Uint8Array>;
+    /**
+     * Pop
+     * Retrieves and removes the head of this queue,
+     * or returns None if this queue is empty.
+     */
+    pop(timeout: number, topic: string, ctx?: Context): Promise<Uint8Array>;
+    /**
+     * Push
+     * Inserts the specified element into this queue if it is possible to do
+     * so immediately without violating capacity restrictions.
+     * When using a capacity-restricted queue, this method is generally
+     * preferable to add, which can fail to insert an element only
+     * by throwing an exception.
+     */
+    push(payload: Uint8Array, metadata: Record<string, string>, topic: string, ctx?: Context): Promise<void>;
+    /**
+     * Release the channel session.
+     */
+    release(timeout: number, topic: string, ctx?: Context): Promise<void>;
+}

package/dist/psi/publisher.d.ts

@@ -0,0 +1,12 @@
+import { Context } from './context';
+import { Event } from '../types';
+export declare abstract class Publisher {
+    /**
+     * Publish
+     */
+    publish(events: Event[], ctx?: Context): Promise<string[]>;
+    /**
+     * Broadcast
+     */
+    broadcast(events: Event[], ctx?: Context): Promise<string[]>;
+}

package/dist/psi/registry.d.ts

@@ -0,0 +1,20 @@
+import { Context } from './context';
+import { Registration } from '../types';
+export declare abstract class Registry {
+    /**
+     * Register
+     */
+    register(registration: Registration<any>, ctx?: Context): Promise<void>;
+    /**
+     * Registers
+     */
+    registers(registrations: Registration<any>[], ctx?: Context): Promise<void>;
+    /**
+     * Unregister
+     */
+    unregister(registration: Registration<any>, ctx?: Context): Promise<void>;
+    /**
+     * Export
+     */
+    export(kind: string, ctx?: Context): Promise<Registration<any>[]>;
+}

package/dist/psi/routable.d.ts

@@ -0,0 +1,37 @@
+import { Context } from './context';
+import { Principal } from '../types';
+export declare abstract class Routable {
+    /**
+     * With
+     * Route with attachments.
+     */
+    with(key: string, value: string, ctx?: Context): Promise<Routable>;
+    /**
+     * WithMap
+     * Route with attachments.
+     */
+    withMap(attachments: Record<string, string>, ctx?: Context): Promise<Routable>;
+    /**
+     * Local
+     * Invoke the service in local network.
+     */
+    local(ctx?: Context): Promise<any>;
+    /**
+     * Any
+     * Invoke the service in a network, it may be local or others.
+     */
+    any(principal: Principal, ctx?: Context): Promise<any>;
+    /**
+     * Many
+     * Invoke the service in many network, it may be local or others. Broadcast mode.
+     */
+    many(principals: Principal[], ctx?: Context): Promise<any[]>;
+}
+export declare class MpcStream {
+    /**
+     */
+    reference?: any;
+    /**
+     */
+    attachments: Record<string, string>;
+}

package/dist/psi/savepoint.d.ts

@@ -0,0 +1,24 @@
+import { Context } from './context';
+import { DtxBranch, DtxDefinition } from '../types';
+export declare abstract class Savepoint {
+    /**
+     * Begin a savepoint, this method will blocked a database transaction connection with timeout.
+     */
+    begin(definition: DtxDefinition, ctx?: Context): Promise<string>;
+    /**
+     * Commit a savepoint.
+     */
+    commit(xid: string, ctx?: Context): Promise<void>;
+    /**
+     * Rollback a savepoint.
+     */
+    rollback(xid: string, ctx?: Context): Promise<void>;
+    /**
+     * Execute a savepoint sql.
+     */
+    execute(branch: DtxBranch, ctx?: Context): Promise<Uint8Array>;
+    /**
+     * Redo dolog void redo before commit.
+     */
+    redo(commit: Uint8Array, ctx?: Context): Promise<void>;
+}

package/dist/psi/scheduler.d.ts

@@ -0,0 +1,47 @@
+import { Context } from './context';
+import { Timeout, Topic } from '../types';
+export declare abstract class Scheduler {
+    /**
+     * Timeout
+     * Schedules the specified {@link Timeout} for one-time execution after the specified delay.
+     */
+    timeout(timeout: Timeout, duration: number, ctx?: Context): Promise<string>;
+    /**
+     * Cron
+     * Schedules with the cron expression. "0 * * 1-3 * ? *"
+     */
+    cron(cron: string, topic: Topic, ctx?: Context): Promise<string>;
+    /**
+     * Period
+     * schedule with fixed duration.
+     */
+    period(duration: number, topic: Topic, ctx?: Context): Promise<string>;
+    /**
+     * Dump max is 1000 items
+     * Releases all resources acquired by this {@link Scheduler} and cancels all
+     * tasks which were scheduled but not executed yet.
+     */
+    dump(ctx?: Context): Promise<string[]>;
+    /**
+     * Cancel
+     * Attempts to cancel the {@link tech.firmer.mesh.types.Timeout} associated with this handle.
+     * If the task has been executed or cancelled already, it will return with
+     * no side effect.
+     */
+    cancel(taskId: string, ctx?: Context): Promise<boolean>;
+    /**
+     * Stop
+     * Attempts to stop the {@link tech.firmer.mesh.types.Timeout} associated with this handle.
+     * If the task has been executed or cancelled already, it will return with
+     * no side effect.
+     */
+    stop(taskId: string, ctx?: Context): Promise<boolean>;
+    /**
+     * Emit the scheduler topic
+     */
+    emit(topic: Topic, ctx?: Context): Promise<void>;
+    /**
+     * Shutdown the scheduler
+     */
+    shutdown(duration: number, ctx?: Context): Promise<void>;
+}

package/dist/psi/sequence.d.ts

@@ -0,0 +1,20 @@
+import { Context } from './context';
+export declare abstract class Sequence {
+    /**
+     * Next 生成全网唯一序列号
+     *
+     * Parameters:
+     * kind - 序列号类型，各个业务保持唯一.
+     * length - 长度
+     */
+    next(kind: string, length: number, ctx?: Context): Promise<string>;
+    /**
+     * Section 获取序列号段.
+     *
+     * Parameters:
+     * kind - 类型
+     * size - 号段大小
+     * length - 长度
+     */
+    section(kind: string, size: number, length: number, ctx?: Context): Promise<string[]>;
+}

package/dist/psi/subscriber.d.ts

@@ -0,0 +1,11 @@
+import { Context } from './context';
+import { Event } from '../types';
+export declare abstract class Subscriber {
+    /**
+     * Subscribe the event with {@link tech.firmer.mesh.macro.Bindings} or {@link tech.firmer.mesh.macro.Binding}
+     *
+     * Parameters:
+     * event - uniform event payload.
+     */
+    subscribe(event: Event, ctx?: Context): Promise<void>;
+}