@dra2020/baseclient 1.0.11 → 1.0.14

package/dist/logserver/logblob.d.ts

@@ -0,0 +1,24 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+import * as Storage from '../storage/all';
+import { LogKey } from './logkey';
+interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+export declare class LogBlob extends Storage.StorageBlob {
+    key: LogKey;
+    constructor(env: Environment, params: Storage.BlobParams);
+    get env(): Environment;
+    get result(): string;
+    static createForDownload(env: Environment, id: string): LogBlob;
+    static createForUpload(env: Environment, id: string, data: string): LogBlob;
+    static createForDelete(env: Environment, id: string): LogBlob;
+    static createForLs(env: Environment): LogBlob;
+    filter(s: string): boolean;
+    asString(): string;
+}
+export {};

package/dist/logserver/logconcat.d.ts

@@ -0,0 +1,55 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+import * as Storage from '../storage/all';
+import { LogBlob } from './logblob';
+interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+export declare class FsmCompact extends FSM.Fsm {
+    blobLs: LogBlob;
+    clusters: {
+        [key: string]: string[];
+    };
+    constructor(env: Environment);
+    get env(): Environment;
+    gatherLogList(logs: string[]): void;
+    tick(): void;
+}
+declare class Permuter {
+    tag: string;
+    entries: {
+        [key: string]: {
+            key: string;
+            to: string;
+            from: string;
+        };
+    };
+    mapper: {
+        [from: string]: string;
+    };
+    length: number;
+    constructor(tag: string);
+    reset(): void;
+    add(fields: string[]): void;
+    map(from: string): string;
+    asCSV(): string[];
+}
+export declare class FsmCompactOne extends FSM.Fsm {
+    key: string;
+    cluster: string[];
+    blobs: LogBlob[];
+    csv: string[];
+    schemas: Permuter;
+    templates: Permuter;
+    constructor(env: Environment, key: string, cluster: string[]);
+    get env(): Environment;
+    loadBlobs(): void;
+    saveBlobs(): void;
+    deleteBlobs(): void;
+    tick(): void;
+}
+export {};

package/dist/logserver/logkey.d.ts

@@ -0,0 +1,28 @@
+export declare function dateToKey(d: Date): string;
+export declare function dateToMonthKey(d: Date): string;
+export declare function dateToYearKey(d: Date): string;
+export declare class LogKey {
+    kind: string;
+    mode: string;
+    date: string;
+    dateKey: string;
+    monthKey: string;
+    yearKey: string;
+    count: string;
+    instance: string;
+    ext: string;
+    constructor();
+    static root(): LogKey;
+    static create(s: string): LogKey;
+    yearClosed(): boolean;
+    monthClosed(): boolean;
+    dateClosed(): boolean;
+    get closed(): boolean;
+    get yearID(): string;
+    get monthID(): string;
+    get dateID(): string;
+    get isYear(): boolean;
+    get isMonth(): boolean;
+    get isDate(): boolean;
+    get isLog(): boolean;
+}

package/dist/memsqs/all.d.ts

@@ -0,0 +1,4 @@
+export * from './queue';
+export * from './client';
+export * from './server';
+export * from './loopback';

package/dist/memsqs/client.d.ts

@@ -0,0 +1,13 @@
+import * as Q from './queue';
+export declare type SQSCallback = (err: any, result: Q.QMessages) => void;
+export declare class SQSClient {
+    private targeturl?;
+    private httpoptions?;
+    private agentPool?;
+    constructor(urlstring?: string);
+    setOptions(queueid: string, options: Q.QQueueOptions, cb: SQSCallback): void;
+    claim(queueid: string, owner: string, groupid: string, cb: SQSCallback): void;
+    send(queueid: string, m: Q.QMessage, cb: SQSCallback): void;
+    remove(queueid: string, m: Q.QMessage, cb: SQSCallback): void;
+    receive(queueid: string, owner: string, cb: SQSCallback): void;
+}

package/dist/memsqs/loopback.d.ts

@@ -0,0 +1,11 @@
+import * as Q from './queue';
+import * as C from './client';
+export declare class SQSClientLoopback {
+    constructor(urlstring?: string);
+    setOptions(queueid: string, options: Q.QQueueOptions, cb: C.SQSCallback): void;
+    claim(queueid: string, owner: string, groupid: string, cb: C.SQSCallback): void;
+    send(queueid: string, m: Q.QMessage, cb: C.SQSCallback): void;
+    remove(queueid: string, m: Q.QMessage, cb: C.SQSCallback): void;
+    receive(queueid: string, owner: string, cb: C.SQSCallback): void;
+    doReceive(): void;
+}

package/dist/memsqs/orderedlist.d.ts

@@ -0,0 +1,19 @@
+export interface OrderedListEntry<T> {
+    prev: OrderedListEntry<T>;
+    next: OrderedListEntry<T>;
+    value: T;
+}
+export declare type OrderedListIndex<T> = {
+    [key: string]: OrderedListEntry<T>;
+};
+export declare class OrderedList<T> {
+    head: OrderedListEntry<T>;
+    tail: OrderedListEntry<T>;
+    index: OrderedListIndex<T>;
+    constructor();
+    isempty(): boolean;
+    clear(): void;
+    insert(key: string, value: T): string;
+    remove(key: string): string;
+    forEach(cb: (value: T) => boolean): void;
+}

package/dist/memsqs/queue.d.ts

@@ -0,0 +1,84 @@
+import * as Util from '../util/all';
+import * as OL from './orderedlist';
+export declare const DefaultPort: number;
+export declare const DefaultServerUrl: string;
+export interface QMessage {
+    messageid: string;
+    groupid: string;
+    seqno?: number;
+    contents?: any;
+    blobid?: string;
+}
+export declare type QMessages = QMessage[];
+interface QMessageHolder {
+    m: QMessage;
+    pending: boolean;
+    deadline: Util.Deadline;
+}
+declare type QMessageList = OL.OrderedList<QMessageHolder>;
+declare type QMessageIndex = {
+    [key: string]: boolean;
+};
+interface QVisibility {
+    owner: string;
+    deadline: Util.Deadline;
+    index: QMessageIndex;
+}
+interface QGroup {
+    id: string;
+    messages: QMessageList;
+    visibility: QVisibility;
+}
+declare type QGroupIndex = {
+    [id: string]: QGroup;
+};
+export interface QQueueOptions {
+    timeoutVisibility: number;
+    timeoutDead: number;
+    timeoutQueueDead: number;
+    receiveLimit: number;
+    longpoll: boolean;
+}
+declare class QQueue {
+    id: string;
+    groups: QGroupIndex;
+    seqno: number;
+    options: QQueueOptions;
+    nHeld: number;
+    lastActive: Util.Elapsed;
+    constructor(id: string, options?: QQueueOptions);
+    dumpLog(): void;
+    setOptions(options: QQueueOptions): void;
+    _group(id: string): QGroup;
+    forEachGroup(cb: (g: QGroup) => boolean): void;
+    forEachMessageHolder(g: QGroup, cb: (h: QMessageHolder) => boolean): void;
+    get isActive(): boolean;
+    checkTimeout(): void;
+    send(m: QMessage): string;
+    claim(owner: string, groupid: string): string;
+    receive(owner: string, result: QMessages): void;
+    removeFromGroup(g: QGroup, m: QMessage): string;
+    remove(m: QMessage): string;
+}
+declare type QQueueIndex = {
+    [id: string]: QQueue;
+};
+export declare class QQueueManager {
+    queues: QQueueIndex;
+    nSent: number;
+    nReceived: number;
+    nRemoved: number;
+    nCulled: number;
+    constructor();
+    _queue(queueid: string): QQueue;
+    checkTimeout(): void;
+    forEach(cb: (q: QQueue) => void): void;
+    dumpLog(): void;
+    setOptions(queueid: string, options: QQueueOptions): void;
+    isLongpoll(queueid: string): boolean;
+    claim(queueid: string, owner: string, groupid: string): string;
+    send(queueid: string, m: QMessage): string;
+    receive(queueid: string, owner: string, result: QMessages): void;
+    remove(queueid: string, m: QMessage): string;
+}
+export {};

package/dist/memsqs/server.d.ts

@@ -0,0 +1,37 @@
+import * as JS from '../jsonstream/all';
+import * as Q from './queue';
+export declare class SQSServer {
+    private port;
+    private server;
+    queuemanager: Q.QQueueManager;
+    longpoll: LongPoll;
+    constructor(port?: number);
+    get running(): boolean;
+    close(): void;
+}
+interface LongPollRequest {
+    deadline: number;
+    request: OneRequest;
+}
+declare class LongPoll {
+    requests: LongPollRequest[];
+    constructor();
+    check(): void;
+    tick(): void;
+    add(one: OneRequest): void;
+}
+declare class OneRequest {
+    server: SQSServer;
+    req: any;
+    res: any;
+    jsonstream: JS.JSONStreamReader;
+    json: any;
+    body: any;
+    constructor(server: SQSServer, req: any, res: any);
+    isDone(): boolean;
+    onRetry(): boolean;
+    onDone(): void;
+    onError(s: string): void;
+    onFinish(): void;
+}
+export {};

package/dist/ot-js/otsession.d.ts

@@ -20,7 +20,6 @@ export declare const FilterRecent: number;
 export declare const FilterTrash: number;
 export declare const FilterPublic: number;
 export declare const FilterOfficial: number;
-export declare const FilterCOI: number;
 export declare const FilterCount: number;
 export declare type Filter = number;
 export declare const PermNone: number;
@@ -84,8 +83,6 @@ export interface SessionProps {
     loadFailed: boolean;
     accessMap: AccessMap;
     revisions: RevisionList;
-    expunged?: boolean;
-    expungeDate?: string;
     xprops?: {
         [prop: string]: string;
     };

package/dist/poly/union.d.ts

@@ -2,7 +2,6 @@ import * as FSM from '../fsm/all';
 import * as Poly from './poly';
 import * as Q from './quad';
 export declare function polyIntersects(p1: any, p2: any): boolean;
-export declare function polyDifference(main: any, parts: any[]): any;
 declare class FsmDifference extends FSM.Fsm {
     accum: any;
     polys: any[];

package/dist/storage/all.d.ts

@@ -0,0 +1,4 @@
+export * from './env';
+export * from './storage';
+export * from './datablob';
+export * from './splitsblob';

package/dist/storage/datablob.d.ts

@@ -0,0 +1,9 @@
+import { Environment } from './env';
+import * as Storage from './storage';
+export declare class DataBlob extends Storage.StorageBlob {
+    constructor(env: Environment, params: Storage.BlobParams);
+    get env(): Environment;
+    get json(): any;
+    static createForJSON(env: Environment, id: string): DataBlob;
+    static createForStream(env: Environment, id: string, bucket?: string): DataBlob;
+}

package/dist/storage/env.d.ts

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

package/dist/storage/splitsblob.d.ts

@@ -0,0 +1,13 @@
+import { Environment } from './env';
+import * as Storage from './storage';
+export declare class SplitsBlob extends Storage.StorageBlob {
+    ls: {
+        [key: string]: Storage.BlobProperties;
+    };
+    constructor(env: Environment, params: Storage.BlobParams);
+    get env(): Environment;
+    get collection(): any;
+    static createForLs(env: Environment): SplitsBlob;
+    static createForUpload(env: Environment, id: string, collection: any): SplitsBlob;
+    static createForDownload(env: Environment, id: string): SplitsBlob;
+}

package/dist/storage/storage.d.ts

@@ -0,0 +1,166 @@
+/// <reference types="node" />
+import * as stream from 'stream';
+import * as FSM from '../fsm/all';
+import { Environment } from './env';
+export declare const ESuccess: number;
+export declare const EFail: number;
+export declare const ENotFound: number;
+export declare const EPending: number;
+export declare const EBadFormat: number;
+export declare type StorageState = number;
+export declare const StorageStateClean = 0;
+export declare const StorageStateDirty = 1;
+export declare const StorageStateSaving = 2;
+export declare const StorageStateLoading = 4;
+export declare const StorageStateLoadCanceled = 8;
+export declare const StorageStateLoadFailed = 16;
+export declare const StorageStateDeleting = 32;
+export declare const StorageStateDeleted = 64;
+export declare const StorageStateListing = 128;
+export declare type BucketMap = {
+    [key: string]: string;
+};
+export declare const BucketDefault = "default";
+export declare const BucketDev = "development";
+export declare const BucketProd = "production";
+export declare const BucketLogs = "logs";
+export declare type TransferUrlOp = 'putObject' | 'getObject';
+export interface TransferParams {
+    op: TransferUrlOp;
+    contentType?: string;
+}
+export declare type DispositionType = 'object' | 'string' | 'buffer' | 'stream' | 'filepath';
+export declare type LoadToFilter = (blob: StorageBlob, a: any) => any;
+export interface BlobParams {
+    id: string;
+    bucket?: string;
+    saveFromType?: DispositionType;
+    saveFrom?: any;
+    loadToType?: DispositionType;
+    loadTo?: any;
+    loadToFilter?: LoadToFilter;
+    deleteAfterLoad?: boolean;
+    suppressDeleteError?: boolean;
+    ContentEncoding?: string;
+    ContentType?: string;
+    CacheControl?: string;
+}
+export declare class FsmTransferUrl extends FSM.Fsm {
+    bucket: string;
+    key: string;
+    params: TransferParams;
+    url: string;
+    constructor(env: Environment, bucket: string, params: TransferParams);
+}
+export interface BlobProperties {
+    Key?: string;
+    ContentLength?: number;
+    ContentDisposition?: string;
+    ContentEncoding?: string;
+    ContentType?: string;
+    ContentLanguage?: string;
+    LastModified?: string;
+    ETag?: string;
+}
+export interface MultiBufferList {
+    buf: Buffer;
+    next: MultiBufferList;
+}
+export declare class MultiBufferPassThrough extends stream.Duplex {
+    _dopush: boolean;
+    _head: MultiBufferList;
+    _tail: MultiBufferList;
+    constructor();
+    _read(): void;
+    _dopushing(): void;
+    _pushChunk(chunk: any): void;
+    _write(chunk: any, encoding: string, cb: any): void;
+    _done(): void;
+    _flush(cb: any): void;
+    _transform(chunk: any, encoding: string, cb: any): void;
+}
+export declare class StorageBlob {
+    _env: Environment;
+    params: BlobParams;
+    state: StorageState;
+    tStarted: Date;
+    fsmSave: FSM.Fsm;
+    fsmLoad: FSM.Fsm;
+    fsmDel: FSM.Fsm;
+    fsmList: FSM.Fsm;
+    _props: FSM.FsmArray;
+    _keys: FSM.FsmArray;
+    constructor(env: Environment, params: BlobParams);
+    get env(): Environment;
+    get keys(): string[];
+    get props(): BlobProperties[];
+    resetList(): void;
+    get fsmArray(): FSM.Fsm;
+    setSaveFrom(t: DispositionType, data: any): void;
+    setLoadTo(t: DispositionType): void;
+    needSave(): boolean;
+    isSaving(): boolean;
+    isLoading(): boolean;
+    isListing(): boolean;
+    setListing(): void;
+    setListed(): void;
+    isDeleting(): boolean;
+    isDeleted(): boolean;
+    isLoadFailed(): boolean;
+    isValid(): boolean;
+    isReadable(): boolean;
+    isDirty(): boolean;
+    isSafeToUnload(): boolean;
+    setDirty(): void;
+    setInit(): void;
+    setLoading(): void;
+    setLoaded(result: number): void;
+    setSaving(): void;
+    setSaved(result: number): void;
+    setDeleting(): void;
+    setDeleted(result: number): void;
+    startLoad(sm: StorageManager): void;
+    startHead(sm: StorageManager): void;
+    checkSave(sm: StorageManager): void;
+    startDelete(sm: StorageManager): void;
+    endSave(br: BlobRequest): void;
+    endLoad(br: BlobRequest): void;
+    endHead(br: BlobRequest): void;
+    endDelete(br: BlobRequest): void;
+    startList(sm: StorageManager, continuationToken?: string): void;
+    endList(br: BlobRequest): void;
+    toLoadStream(): stream.Readable;
+    setLoadStream(rs: stream.Readable): void;
+}
+export interface BlobRequest {
+    blob: StorageBlob;
+    result(): number;
+    asBuffer(): Buffer;
+    asString(): string;
+    asError(): string;
+    asProps(): BlobProperties[];
+    continuationToken(): string;
+}
+export interface BlobRequestIndex {
+    [key: string]: BlobRequest;
+}
+export declare class StorageManager {
+    _env: Environment;
+    saveBlobIndex: BlobRequestIndex;
+    loadBlobIndex: BlobRequestIndex;
+    headBlobIndex: BlobRequestIndex;
+    delBlobIndex: BlobRequestIndex;
+    lsBlobIndex: BlobRequestIndex;
+    onList: any;
+    bucketMap: BucketMap;
+    constructor(env: Environment, bucketMap?: BucketMap);
+    save(blob: StorageBlob): void;
+    load(blob: StorageBlob): void;
+    del(blob: StorageBlob): void;
+    head(blob: StorageBlob): void;
+    ls(blob: StorageBlob, continuationToken?: string): void;
+    createTransferUrl(params: TransferParams): FsmTransferUrl;
+    on(eventName: string, cb: any): void;
+    off(eventName: string, cb: any): void;
+    emit(eventName: string, blob: StorageBlob): void;
+}

package/dist/storages3/all.d.ts

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

package/dist/storages3/s3.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import * as Context from '../context/all';
+import * as Storage from '../storage/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+export interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+declare class S3Request implements Storage.BlobRequest {
+    blob: Storage.StorageBlob;
+    req: any;
+    res: any;
+    data: any;
+    err: any;
+    constructor(blob: Storage.StorageBlob);
+    continuationToken(): string;
+    result(): number;
+    decode(): void;
+    asString(): string;
+    asBuffer(): Buffer;
+    _dataToProps(data: any): Storage.BlobProperties;
+    asProps(): Storage.BlobProperties[];
+    asError(): string;
+}
+export declare class FsmStreamLoader extends FSM.Fsm {
+    sm: StorageManager;
+    blob: Storage.StorageBlob;
+    param: any;
+    err: any;
+    contentLength: number;
+    contentPos: number;
+    readStream: Storage.MultiBufferPassThrough;
+    passThrough: Storage.MultiBufferPassThrough;
+    constructor(env: Environment, sm: StorageManager, blob: Storage.StorageBlob);
+    get env(): Environment;
+    setStreamError(): void;
+    tick(): void;
+}
+export declare class FsmTransferUrl extends Storage.FsmTransferUrl {
+    storageManager: StorageManager;
+    constructor(env: Environment, bucket: string, params: Storage.TransferParams);
+}
+export declare class StorageManager extends Storage.StorageManager {
+    s3: any;
+    count: number;
+    constructor(env: Environment, bucketMap?: Storage.BucketMap);
+    get env(): Environment;
+    lookupBucket(s: string): string;
+    blobBucket(blob: Storage.StorageBlob): string;
+    load(blob: Storage.StorageBlob): void;
+    _finishLoad(blob: Storage.StorageBlob, id: string, rq: S3Request, err: any, data: any): void;
+    head(blob: Storage.StorageBlob): void;
+    safeSaveFromPath(blob: Storage.StorageBlob, rq: S3Request, id: string, trace: LogAbstract.AsyncTimer): any;
+    save(blob: Storage.StorageBlob): void;
+    del(blob: Storage.StorageBlob): void;
+    ls(blob: Storage.StorageBlob, continuationToken?: string): void;
+    createTransferUrl(params: Storage.TransferParams): Storage.FsmTransferUrl;
+}
+export {};

package/docs/dbabstract.md

@@ -0,0 +1,2 @@
+# dbabstract
+Abstract database layer to allow local mock.

package/docs/dbdynamo.md

@@ -0,0 +1,2 @@
+# dbdynamo
+Dynamo abstraction layer

package/docs/fsmfile.md

@@ -0,0 +1,2 @@
+# fsmfile
+FSM interface for asynchronous file APIs, including JSON streaming.

package/docs/jsonstream.md

@@ -0,0 +1,44 @@
+# jsonstream
+Streaming replacement for JSON.parse and JSON.stringify for NodeJS projects.
+
+## JSONStreamReader
+
+Initialize with optional parameters to set maximum token sizes.
+Call start() with a stream in Buffer mode to start parsing.
+The following standard events are emitted.
+Note: If the 'error' event is emitted, no 'end' event is emitted.
+
+### 'error'
+
+Passes an object of type Error with detailed information about parsing error.
+
+### 'end'
+
+Passes an object of type any that contains the fully parsed object.
+
+
+### 'close'
+
+Passed after 'end' event when stream is closed.
+
+### reader.emitIncremental(name: string)
+
+If emitIncremental is called, individual properties associated with the given named property are returned
+incrementally rather than appended to the aggregate object.
+
+The following events are emitted when encountering a value in such a field.
+
+### 'array'
+
+Passes the name of the field passed to emitIncremental that caused this event and the value that would have
+been pushed into the array.
+
+### 'object'
+
+Passes the name of the field passed to emitIncremental that caused this event, the property name that would
+have been added to the object and the property value.
+
+
+## JSONStreamWriter
+
+Initialize with optional parameters and then call start() with a writeable stream and the object to write.

package/docs/lambda.md

@@ -0,0 +1,2 @@
+# lambda
+Implementation of lambda abstraction against AWS Lambda

package/docs/logserver.md

@@ -0,0 +1,2 @@
+# log
+Accept logging information and save to storage in CSV format as necessary.

package/docs/storage.md

@@ -0,0 +1,2 @@
+# storage
+Abstract for storage state management

package/docs/storages3.md

@@ -0,0 +1,2 @@
+# storages3
+Implementation of storage abstraction against AWS S3