@dra2020/baseclient 1.0.13 → 1.0.14

package/dist/context/all.d.ts

@@ -0,0 +1 @@
+export * from './context';

package/dist/context/context.d.ts

@@ -0,0 +1,13 @@
+export declare type ContextValues = {
+    [key: string]: any;
+};
+export interface IContext {
+    setDefaults: (o: ContextValues) => void;
+    setValues: (o: ContextValues) => void;
+    xvalue: (prop: string) => any;
+    xset: (prop: string) => boolean;
+    xflag: (prop: string) => boolean;
+    xnumber: (prop: string) => number;
+    xstring: (prop: string) => string;
+}
+export declare function create(): IContext;

package/dist/dbabstract/all.d.ts

@@ -0,0 +1 @@
+export * from './db';

package/dist/dbabstract/db.d.ts

@@ -0,0 +1,83 @@
+import * as LogAbstract from '../logabstract/all';
+import * as Context from '../context/all';
+import * as Storage from '../storage/all';
+import * as FSM from '../fsm/all';
+export declare const FSM_CREATING: number;
+export declare const FSM_NEEDRELEASE: number;
+export declare const FSM_RELEASING: number;
+export declare const FSM_READING: number;
+export interface DBEnvironment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+export declare function fromCompactSchema(c: any): any;
+export declare function fromCompactKey(c: any): any;
+export declare function fromCompactIndex(c: any): any;
+export declare function toCompactSchema(s: any): any;
+export declare class DBClient extends FSM.Fsm {
+    constructor(env: DBEnvironment);
+    get env(): DBEnvironment;
+    createCollection(name: string, options: any): DBCollection;
+    createStream(col: DBCollection): FSM.FsmArray;
+    closeStream(col: DBCollection): void;
+    createUpdate(col: DBCollection, query: any, values: any): DBUpdate;
+    createUnset(col: DBCollection, query: any, values: any): DBUnset;
+    createDelete(col: DBCollection, query: any): DBDelete;
+    createFind(col: DBCollection, filter: any): DBFind;
+    createQuery(col: DBCollection, filter: any): DBQuery;
+    createIndex(col: DBCollection, uid: string): DBIndex;
+    createClose(): DBClose;
+    close(): void;
+}
+export declare class DBCollection extends FSM.Fsm {
+    name: string;
+    options: any;
+    col: any;
+    client: DBClient;
+    constructor(env: DBEnvironment, client: DBClient, name: string, options: any);
+}
+export declare class DBUpdate extends FSM.Fsm {
+    col: DBCollection;
+    query: any;
+    values: any;
+    result: any;
+    constructor(env: DBEnvironment, col: DBCollection, query: any, values: any);
+}
+export declare class DBUnset extends FSM.Fsm {
+    col: DBCollection;
+    query: any;
+    values: any;
+    result: any;
+    constructor(env: DBEnvironment, col: DBCollection, query: any, values: any);
+}
+export declare class DBDelete extends FSM.Fsm {
+    col: DBCollection;
+    query: any;
+    result: any;
+    constructor(env: DBEnvironment, col: DBCollection, query: any);
+}
+export declare class DBFind extends FSM.Fsm {
+    col: DBCollection;
+    filter: any;
+    result: any;
+    constructor(env: DBEnvironment, col: DBCollection, filter: any);
+}
+export declare class DBQuery extends FSM.Fsm {
+    col: DBCollection;
+    filter: any;
+    fsmResult: FSM.FsmArray;
+    constructor(env: DBEnvironment, col: DBCollection, filter: any);
+    get result(): any[];
+}
+export declare class DBIndex extends FSM.Fsm {
+    col: DBCollection;
+    uid: string;
+    constructor(env: DBEnvironment, col: DBCollection, uid: string);
+}
+export declare class DBClose extends FSM.Fsm {
+    client: DBClient;
+    constructor(env: DBEnvironment, client: DBClient);
+    tick(): void;
+}

package/dist/dbdynamo/all.d.ts

@@ -0,0 +1 @@
+export * from './dbdynamo';

package/dist/dbdynamo/dbdynamo.d.ts

@@ -0,0 +1,190 @@
+import * as DynamoDB from 'aws-sdk/clients/dynamodb';
+import * as DynamoDBStreams from 'aws-sdk/clients/dynamodbstreams';
+import * as Util from '../util/all';
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+import * as DB from '../dbabstract/all';
+import * as Storage from '../storage/all';
+export interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+export interface EnvironmentEx {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+    dbx: DynamoClient;
+}
+declare class Deadline {
+    elapsed: Util.Elapsed;
+    msDeadline: number;
+    constructor(msDeadline: number);
+    start(): void;
+    get msRemaining(): number;
+    get passed(): boolean;
+}
+declare class FsmAPIWatch extends FSM.Fsm {
+    constructor(env: Environment);
+    get env(): Environment;
+    tick(): void;
+}
+declare class FsmListTables extends FSM.Fsm {
+    tables: any;
+    workStack: string[];
+    constructor(env: Environment);
+    get env(): EnvironmentEx;
+    tick(): void;
+}
+export declare function create(env: Environment): DB.DBClient;
+export declare class DynamoClient extends DB.DBClient {
+    serializerUpdate: FSM.FsmSerializer;
+    fsmAPIWatch: FsmAPIWatch;
+    fsmListTables: FsmListTables;
+    dynamodb: DynamoDB;
+    dynamostream: DynamoDBStreams;
+    pendingCols: DynamoCollection[];
+    existingCols: {
+        [name: string]: DynamoCollection;
+    };
+    bList: boolean;
+    constructor(env: Environment);
+    get env(): EnvironmentEx;
+    get Production(): boolean;
+    get DBName(): string;
+    get dynamoErrorFrequency(): number;
+    createCollection(name: string, options: any): DB.DBCollection;
+    createStream(col: DynamoCollection): FSM.FsmArray;
+    closeStream(col: DynamoCollection): void;
+    ensureCollection(col: DynamoCollection): void;
+    createUpdate(col: DynamoCollection, query: any, values: any): DB.DBUpdate;
+    createUnset(col: DynamoCollection, query: any, values: any): DB.DBUnset;
+    createDelete(col: DynamoCollection, query: any): DB.DBDelete;
+    createFind(col: DynamoCollection, filter: any): DB.DBFind;
+    createQuery(col: DynamoCollection, filter: any): DB.DBQuery;
+    createIndex(col: DynamoCollection, uid: string): DB.DBIndex;
+    createClose(): DB.DBClose;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoCollection extends DB.DBCollection {
+    attributeIndex: any;
+    keyIndex: any;
+    fsmStream: FsmTableStream;
+    constructor(env: Environment, client: DynamoClient, name: string, options: any);
+    get env(): Environment;
+    get dynclient(): DynamoClient;
+    get dynamodb(): DynamoDB;
+    createStream(): FSM.FsmArray;
+    closeStream(): void;
+    constructIndex(): void;
+    addConditionExpression(query: any, key: any): void;
+    toInternalQuery(query: any): any;
+    toInternalExpression(o: any): any;
+    toTestExpression(expr: any): string;
+    toUpdateExpression(expr: any): string;
+    toRemoveExpression(expr: any): string;
+    toExternal(result: any): any;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoUpdate extends DB.DBUpdate {
+    trace: LogAbstract.AsyncTimer;
+    constructor(env: Environment, col: DynamoCollection, query: any, values: any);
+    get env(): Environment;
+    get dyncol(): DynamoCollection;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoUnset extends DB.DBUnset {
+    trace: LogAbstract.AsyncTimer;
+    constructor(env: Environment, col: DynamoCollection, query: any, values: any);
+    get env(): Environment;
+    get dyncol(): DynamoCollection;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoDelete extends DB.DBDelete {
+    trace: LogAbstract.AsyncTimer;
+    constructor(env: Environment, col: DynamoCollection, query: any);
+    get env(): Environment;
+    get dyncol(): DynamoCollection;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoFind extends DB.DBFind {
+    trace: LogAbstract.AsyncTimer;
+    constructor(env: Environment, col: DynamoCollection, filter: any);
+    get env(): Environment;
+    get dyncol(): DynamoCollection;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoQuery extends DB.DBQuery {
+    trace: LogAbstract.AsyncTimer;
+    lastKey: any;
+    constructor(env: Environment, col: DynamoCollection, filter: any);
+    get env(): Environment;
+    get dyncol(): DynamoCollection;
+    forceError(): boolean;
+    doScan(): void;
+    tick(): void;
+}
+export declare class DynamoIndex extends DB.DBIndex {
+    constructor(env: Environment, col: DynamoCollection, uid: string);
+}
+export declare class DynamoClose extends DB.DBClose {
+    constructor(env: Environment, client: DynamoClient);
+}
+interface RangeDescription {
+    StartingSequenceNumber: string;
+    EndingSequenceNumber?: string;
+}
+interface ShardDescription {
+    ShardId: string;
+    SequenceNumberRange: RangeDescription;
+    ShardIterator?: string;
+    ParentShardId?: string;
+    LastSequenceNumber?: string;
+}
+export declare class FsmTableShards extends FSM.Fsm {
+    table: any;
+    stream: any;
+    lastKey: string;
+    fsmResult: FSM.FsmArray;
+    constructor(env: Environment, table: any);
+    get env(): EnvironmentEx;
+    tick(): void;
+}
+declare class FsmReadOneShard extends FSM.Fsm {
+    col: DynamoCollection;
+    stream: any;
+    shard: ShardDescription;
+    shardClosed: boolean;
+    fsmResult: FSM.FsmArray;
+    elapsed: Util.Elapsed;
+    nTries: number;
+    deadline: Deadline;
+    constructor(env: Environment, col: DynamoCollection, stream: any, shard: ShardDescription, fsmResult: FSM.FsmArray);
+    get env(): EnvironmentEx;
+    tick(): void;
+}
+export declare class FsmTableStream extends FSM.Fsm {
+    col: DynamoCollection;
+    table: any;
+    fsmShards: FsmTableShards;
+    shardsDone: any;
+    shardsLast: any;
+    shardsQueue: FsmReadOneShard[];
+    fsmResult: FSM.FsmArray;
+    deadline: Deadline;
+    constructor(env: Environment, col: DB.DBCollection);
+    get env(): Environment;
+    end(): void;
+    error(): void;
+    tick(): void;
+}
+export {};

package/dist/filterexpr/all.d.ts

@@ -0,0 +1 @@
+export * from './filterexpr';

package/dist/filterexpr/filterexpr.d.ts

@@ -0,0 +1,64 @@
+import * as Util from '../util/all';
+declare enum TokType {
+    Text = 0,
+    OpenParen = 1,
+    CloseParen = 2,
+    Not = 3,
+    And = 4,
+    Or = 5,
+    Colon = 6,
+    GreaterThan = 7,
+    GreaterThanEqual = 8,
+    Equal = 9,
+    LessThan = 10,
+    LessThanEqual = 11,
+    NotEqual = 12
+}
+interface Token {
+    tt: TokType;
+    text?: string;
+}
+interface Clause {
+    op: Token;
+    operand1?: Clause;
+    operand2?: Clause;
+}
+declare class Lexer {
+    coder: Util.Coder;
+    tokens: Token[];
+    buf: Uint8Array;
+    tok: Uint8Array;
+    toklen: number;
+    n: number;
+    constructor(coder: Util.Coder, expr?: string);
+    set(expr: string): void;
+    pushString(s: string): void;
+    pushText(bForce?: boolean): void;
+    pushSpecial(tt: TokType): void;
+    lex(): void;
+}
+declare class Parser {
+    clauses: Clause[];
+    constructor();
+    get clause(): Clause;
+    initFromTokens(tokens: Token[]): void;
+    initFromClauses(clauses: Clause[]): void;
+    convertOpToText(): void;
+    combineParenthetical(): void;
+    combineUnary(): void;
+    combineColon(): void;
+    combineBinary(tt: TokType): void;
+    combineImplicitAnd(): void;
+    clausesFromTokens(tokens: Token[]): void;
+}
+export declare class FilterExpr {
+    lexer: Lexer;
+    parser: Parser;
+    constructor(coder: Util.Coder, expr?: string);
+    set(expr: string): void;
+    test(o: any, types?: any): boolean;
+    asString(): string;
+    asStringClause(clause: Clause): string;
+    testClause(o: any, types: any, clause: Clause, prop?: string, relation?: TokType): boolean;
+}
+export {};

package/dist/fsm/all.d.ts

@@ -0,0 +1 @@
+export * from './fsm';

package/dist/fsm/fsm.d.ts

@@ -0,0 +1,118 @@
+import * as Util from '../util/all';
+export declare const FSM_STARTING: number;
+export declare const FSM_PENDING: number;
+export declare const FSM_DONE: number;
+export declare const FSM_ERROR: number;
+export declare const FSM_RELEASED: number;
+export declare const FSM_CUSTOM1: number;
+export declare const FSM_CUSTOM2: number;
+export declare const FSM_CUSTOM3: number;
+export declare const FSM_CUSTOM4: number;
+export declare const FSM_CUSTOM5: number;
+export declare const FSM_CUSTOM6: number;
+export declare const FSM_CUSTOM7: number;
+export declare const FSM_CUSTOM8: number;
+export declare const FSM_CUSTOM9: number;
+export declare type FsmIndex = {
+    [key: number]: Fsm;
+};
+export declare class FsmManager {
+    theId: number;
+    theEpoch: number;
+    bTickSet: boolean;
+    theTickList: FsmIndex;
+    theBusyLoopCount: number;
+    constructor();
+    forceTick(fsm: Fsm): void;
+    doTick(): void;
+}
+export interface FsmEnvironment {
+    fsmManager: FsmManager;
+}
+export declare class Fsm {
+    id: number;
+    state: number;
+    dependentError: boolean;
+    epochDone: number;
+    _env: FsmEnvironment;
+    _waitOn: FsmIndex;
+    _waitedOn: FsmIndex;
+    constructor(env: FsmEnvironment);
+    get env(): FsmEnvironment;
+    get manager(): FsmManager;
+    get done(): boolean;
+    get ready(): boolean;
+    get iserror(): boolean;
+    get isDependentError(): boolean;
+    setDependentError(): void;
+    clearDependentError(): void;
+    get ticked(): boolean;
+    get nWaitOn(): number;
+    get nWaitedOn(): number;
+    waitOn(fsm: Fsm | Fsm[]): Fsm;
+    setState(state: number): void;
+    end(state?: number): void;
+    preTick(): void;
+    tick(): void;
+}
+export declare class FsmOnDone extends Fsm {
+    cb: any;
+    fsm: Fsm | Fsm[];
+    constructor(env: FsmEnvironment, fsm: Fsm | Fsm[], cb: any);
+    tick(): void;
+}
+export declare class FsmSleep extends Fsm {
+    delay: number;
+    constructor(env: FsmEnvironment, delay: number);
+    tick(): void;
+}
+export declare type SerializerIndex = {
+    [key: string]: Fsm;
+};
+export declare class FsmSerializer extends Fsm {
+    index: SerializerIndex;
+    constructor(env: FsmEnvironment);
+    serialize(id: string, fsm?: Fsm): Fsm;
+    tick(): void;
+}
+declare type FsmArrayMap = {
+    [key: string]: Fsm[];
+};
+export declare class FsmTracker {
+    env: FsmEnvironment;
+    map: FsmArrayMap;
+    constructor(env: FsmEnvironment);
+    _track(uid: string, fsm: Fsm): void;
+    _untrack(uid: string, fsm: Fsm): void;
+    track(uid: string, fsm: Fsm): Fsm;
+    maybeWait(uid: string, fsm: Fsm): void;
+}
+export interface LoopOptions {
+    minRepeatInterval?: number;
+    exitOnError?: boolean;
+}
+export declare const DefaultLoopOptions: {
+    minRepeatInterval: number;
+    exitOnError: boolean;
+};
+export declare class FsmLoop extends Fsm {
+    fsm: Fsm;
+    options: LoopOptions;
+    elapsed: Util.Elapsed;
+    constructor(env: FsmEnvironment, fsm: Fsm, options?: LoopOptions);
+    tick(): void;
+}
+export interface ISet {
+    test: (o: any) => boolean;
+    reset: () => void;
+}
+export declare class FsmArray extends Fsm {
+    a: any[];
+    iset: ISet;
+    constructor(env: FsmEnvironment, iset?: ISet);
+    push(o: any): void;
+    concat(a: any[]): void;
+    splice(i?: number, n?: number): void;
+    reset(): void;
+}
+export {};

package/dist/fsmfile/all.d.ts

@@ -0,0 +1 @@
+export * from './fsmfile';

package/dist/fsmfile/fsmfile.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+export interface Environment {
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+}
+export declare class FsmUnlink extends FSM.Fsm {
+    path: string;
+    err: any;
+    constructor(env: Environment, path: string);
+    tick(): void;
+}
+export declare class FsmMkdir extends FSM.Fsm {
+    dir: string;
+    bAllowExist: boolean;
+    err: any;
+    constructor(env: Environment, dir: string, bAllowExist?: boolean);
+    tick(): void;
+}
+export declare class FsmRmdir extends FSM.Fsm {
+    dir: string;
+    err: any;
+    constructor(env: Environment, dir: string);
+    tick(): void;
+}
+export declare class FsmLs extends FSM.Fsm {
+    dir: string;
+    err: any;
+    entries: string[];
+    constructor(env: Environment, dir: string);
+    tick(): void;
+}
+export declare class FsmReadFile extends FSM.Fsm {
+    path: string;
+    result: string;
+    err: any;
+    constructor(env: Environment, path: string);
+    tick(): void;
+}
+export declare class FsmWriteFile extends FSM.Fsm {
+    path: string;
+    contents: string | Buffer;
+    err: any;
+    constructor(env: Environment, path: string, contents: string | Buffer);
+    tick(): void;
+}

package/dist/jsonstream/all.d.ts

@@ -0,0 +1 @@
+export * from './jsonstream';

package/dist/jsonstream/jsonstream.d.ts

@@ -0,0 +1,130 @@
+/// <reference types="node" />
+import * as Stream from 'stream';
+import * as Events from 'events';
+export declare class Readable extends Events.EventEmitter {
+    constructor();
+}
+export declare class Writable extends Events.EventEmitter {
+    constructor();
+    write(b: any, encoding?: BufferEncoding, cb?: () => void): boolean;
+    end(): void;
+}
+export declare class BufferWritable extends Writable {
+    _bufs: Buffer[];
+    _buf: Buffer;
+    constructor();
+    write(b: any, encoding?: BufferEncoding, cb?: () => void): boolean;
+    end(): void;
+}
+export declare class BufferReadable extends Stream.Readable {
+    _b: Buffer;
+    constructor(b: Buffer);
+    _read(): void;
+}
+export declare class MultiBufferReadable extends Stream.Readable {
+    constructor();
+    _read(): void;
+    more(buf: Buffer): void;
+    end(): void;
+}
+declare enum ReadState {
+    Start = 0,
+    ObjectPropertyStart = 1,
+    ObjectPropertyEnd = 2,
+    ValueStart = 3,
+    ValueEnd = 4,
+    InName = 5,
+    InNameBackslash = 6,
+    NeedColon = 7,
+    InNumber = 8,
+    InString = 9,
+    InStringBackslash = 10,
+    InTrue = 11,
+    InFalse = 12,
+    InNull = 13,
+    InUndefined = 14,
+    Error = 15,
+    Ended = 16
+}
+declare enum TokType {
+    TTNone = 0,
+    TTArray = 1,
+    TTObject = 2,
+    TTName = 3,
+    TTString = 4,
+    TTNumber = 5,
+    TTTrue = 6,
+    TTFalse = 7,
+    TTNull = 8,
+    TTUndefined = 9
+}
+interface Token {
+    tt: TokType;
+    v: any;
+    emit?: string;
+}
+export interface JSONStreamOptions {
+    maxTokenSize?: number;
+    outBufferSize?: number;
+    encoding?: BufferEncoding;
+    syncChunkSize?: number;
+}
+export declare class JSONStreamReader extends Events.EventEmitter {
+    _s: Readable;
+    _charCount: number;
+    _lineCount: number;
+    _state: ReadState;
+    _tok: Buffer;
+    _tokLen: number;
+    _stack: Token[];
+    _result: any;
+    _incr: any;
+    _options: JSONStreamOptions;
+    _chunks: Buffer[];
+    _chunkCur: number;
+    _chunkIndex: number;
+    _chunkScheduled: boolean;
+    _ended: boolean;
+    _closed: boolean;
+    constructor(options?: JSONStreamOptions);
+    start(s: Readable): void;
+    finish(): void;
+    emitIncremental(name: string): void;
+    pushToken(tok: Token): void;
+    private badJSON;
+    private startTok;
+    private addToTok;
+    private consumeTok;
+    private produceValue;
+    private produceValidatedValue;
+    private onData;
+    private scheduleNext;
+    private nextChunk;
+    private onClose;
+    private doClose;
+    private onError;
+    private onEnd;
+    private doEnd;
+}
+interface ObjectWriteState {
+    o: any;
+    keys: string[];
+    index: number;
+}
+export declare class JSONStreamWriter extends Events.EventEmitter {
+    _s: Writable;
+    _stack: ObjectWriteState[];
+    _chunk: Buffer;
+    _chunkLen: number;
+    _options: JSONStreamOptions;
+    _bDone: boolean;
+    constructor(options?: JSONStreamOptions);
+    start(o: any, s: Writable): void;
+    addToChunk(s: string): boolean;
+    drainChunk(): boolean;
+    onDrain(): void;
+    onError(e: Error): void;
+    onClose(): void;
+    onFinish(): void;
+}
+export {};

package/dist/lambda/all.d.ts

@@ -0,0 +1 @@
+export * from './lambda';

package/dist/lambda/env.d.ts

@@ -0,0 +1,10 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+import * as Lambda from './lambda';
+export interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    lambdaManager: Lambda.Manager;
+}