oak-domain 1.0.0

package/lib/types/Geo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/Locale.d.ts

@@ -0,0 +1,24 @@
+import { EntityShape } from "./Entity";
+declare type Language = 'zh_CN' | 'en_US';
+declare type LocaleOfSchema<S extends Record<string, any>> = {
+    [A in keyof Required<Omit<S, keyof EntityShape>>]: string;
+};
+declare type LocaleOfStringEnum<A extends string> = {
+    [K in A]: string;
+};
+declare type LocaleOfValue<V extends Record<string, string>> = {
+    [K in keyof V]: {
+        [K2 in V[K]]: string;
+    };
+};
+export declare type LocaleDef<Sc extends Record<string, any>, Ac extends string, R extends string, V extends Record<string, string>> = {
+    [L in Language]?: {
+        attr: LocaleOfSchema<Sc> & {
+            [A in keyof V]: string;
+        };
+        action?: LocaleOfStringEnum<Ac>;
+        r?: LocaleOfStringEnum<R>;
+        v?: LocaleOfValue<V>;
+    };
+};
+export {};

package/lib/types/Locale.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/Logger.d.ts

@@ -0,0 +1,5 @@
+export interface Logger {
+    error(...data: any[]): void;
+    info(...data: any[]): void;
+    log(...data: any[]): void;
+}

package/lib/types/Logger.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/lib/types/Polyfill.d.ts

@@ -0,0 +1,23 @@
+export declare type OmitInferKey<T, R> = {
+    [K in keyof T as T extends R ? never : K]: T[K];
+};
+export declare type OmitInferValue<T, R> = {
+    [K in keyof T as T extends R ? never : K]: T[K];
+};
+export declare type ValueOf<Obj> = Obj[keyof Obj];
+export declare type OneOnly<Obj, Key extends keyof Obj> = {
+    [key in Exclude<keyof Obj, Key>]?: undefined;
+} & Pick<Obj, Key>;
+export declare type OneOfByKey<Obj> = {
+    [key in keyof Obj]: OneOnly<Obj, key>;
+};
+export declare type OneOf<Obj> = ValueOf<OneOfByKey<Obj>>;
+declare type IsOptional<T, K extends keyof T> = {
+    [K1 in Exclude<keyof T, K>]: T[K1];
+} & {
+    K?: T[K];
+} extends T ? K : never;
+export declare type OptionalKeys<T> = {
+    [K in keyof T]: IsOptional<T, K>;
+}[keyof T];
+export {};

package/lib/types/Polyfill.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/RowStore.d.ts

@@ -0,0 +1,22 @@
+import { OperationResult, OperateOption, EntityDict, SelectionResult } from './Entity';
+import { Context } from './Context';
+import { StorageSchema } from './Storage';
+import { OakErrorDefDict } from '../OakError';
+import { SelectOption } from '.';
+export declare type TxnOption = {
+    isolationLevel: 'repeatable read' | 'serializable';
+};
+export declare abstract class RowStore<ED extends EntityDict, Cxt extends Context<ED>> {
+    static $$LEVEL: string;
+    static $$CODES: OakErrorDefDict;
+    protected storageSchema: StorageSchema<ED>;
+    abstract operate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option?: OP): Promise<OperationResult<ED>>;
+    abstract select<T extends keyof ED, S extends ED[T]['Selection'], OP extends SelectOption>(entity: T, selection: S, context: Cxt, option?: OP): Promise<SelectionResult<ED[T]['Schema'], S['data']>>;
+    abstract count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option?: OP): Promise<number>;
+    constructor(storageSchema: StorageSchema<ED>);
+    abstract begin(option?: TxnOption): Promise<string>;
+    abstract commit(txnId: string): Promise<void>;
+    abstract rollback(txnId: string): Promise<void>;
+    getSchema(): StorageSchema<ED>;
+    mergeOperationResult(result: OperationResult<ED>, toBeMerged: OperationResult<ED>): void;
+}

package/lib/types/RowStore.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowStore = void 0;
+var lodash_1 = require("../utils/lodash");
+var RowStore = /** @class */ (function () {
+    function RowStore(storageSchema) {
+        this.storageSchema = storageSchema;
+    }
+    RowStore.prototype.getSchema = function () {
+        return this.storageSchema;
+    };
+    RowStore.prototype.mergeOperationResult = function (result, toBeMerged) {
+        for (var entity in toBeMerged) {
+            for (var action in toBeMerged[entity]) {
+                var value = (0, lodash_1.get)(result, "".concat(entity, ".").concat(action));
+                if (typeof value === 'number') {
+                    (0, lodash_1.set)(result, "".concat(entity, ".").concat(action), value + toBeMerged[entity][action]);
+                }
+                else {
+                    (0, lodash_1.set)(result, "".concat(entity, ".").concat(action), toBeMerged[entity][action]);
+                }
+            }
+        }
+    };
+    RowStore.$$LEVEL = 'store';
+    RowStore.$$CODES = {
+        primaryKeyConfilict: [1, '主键重复'],
+        expressionUnresolved: [2, '表达式无法计算完成'],
+        nodeIdRepeated: [3, '查询或投影中的nodeId重复'],
+    };
+    return RowStore;
+}());
+exports.RowStore = RowStore;

package/lib/types/Storage.d.ts

@@ -0,0 +1,48 @@
+import { EntityDict, EntityShape, InstinctiveAttributes } from './Entity';
+import { DataType, DataTypeParams } from './schema/DataTypes';
+export declare type Ref = 'ref';
+export interface Column<SH extends EntityShape> {
+    name: keyof SH | `${string}State`;
+    size?: number;
+    direction?: 'ASC' | 'DESC';
+}
+export interface IndexConfig {
+    unique?: boolean;
+    type?: 'fulltext' | 'btree' | 'hash' | 'spatial';
+    parser?: 'ngram';
+}
+export interface Index<SH extends EntityShape> {
+    name: string;
+    attributes: Column<SH>[];
+    config?: IndexConfig;
+}
+export interface Attribute {
+    type: DataType | Ref;
+    params?: DataTypeParams;
+    ref?: string;
+    onRefDelete?: 'delete' | 'setNull' | 'ignore';
+    default?: string | number | boolean;
+    notNull?: boolean;
+    unique?: boolean;
+}
+export declare type Attributes<SH extends EntityShape> = Omit<{
+    [attrName in keyof SH]: Attribute;
+}, InstinctiveAttributes>;
+export interface EntityConfig {
+}
+export declare type UniqConstraint<SH extends EntityShape> = {
+    attributes: Array<keyof SH>;
+    type?: string;
+};
+export interface StorageDesc<SH extends EntityShape> {
+    storageName?: string;
+    comment?: string;
+    attributes: Attributes<SH>;
+    uniqueConstraints?: UniqConstraint<SH>[];
+    indexes?: Index<SH>[];
+    config?: EntityConfig;
+    view?: true;
+}
+export declare type StorageSchema<ED extends EntityDict> = {
+    [K in keyof ED]: StorageDesc<ED[K]['OpSchema']>;
+};

package/lib/types/Storage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/Trigger.d.ts

@@ -0,0 +1,105 @@
+import { SelectOption, SelectRowShape } from ".";
+import { GenericAction } from "../actions/action";
+import { EntityDict, OperateOption } from "../types/Entity";
+import { EntityShape, TriggerDataAttribute, TriggerTimestampAttribute } from "../types/Entity";
+import { Context } from "./Context";
+export declare type CheckerType = 'user' | 'row' | 'data';
+export interface CreateTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> {
+    checkerType?: CheckerType;
+    entity: T;
+    name: string;
+    action: 'create';
+    check?: (operation: ED[T]['Create']) => boolean;
+    fn: (event: {
+        operation: ED[T]['Create'];
+    }, context: Cxt, option?: OperateOption) => Promise<number>;
+}
+export interface CreateTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends CreateTriggerBase<ED, T, Cxt> {
+    when: 'before' | 'after';
+}
+export interface CreateTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends CreateTriggerBase<ED, T, Cxt> {
+    when: 'commit';
+    strict?: 'takeEasy' | 'makeSure';
+}
+export declare type CreateTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = CreateTriggerInTxn<ED, T, Cxt> | CreateTriggerCrossTxn<ED, T, Cxt>;
+export interface UpdateTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> {
+    checkerType?: CheckerType;
+    entity: T;
+    name: string;
+    action: Exclude<ED[T]['Action'], GenericAction> | 'update' | Array<Exclude<ED[T]['Action'], GenericAction> | 'update'>;
+    attributes?: keyof ED[T]['OpSchema'] | Array<keyof ED[T]['OpSchema']>;
+    check?: (operation: ED[T]['Update']) => boolean;
+    fn: (event: {
+        operation: ED[T]['Update'];
+    }, context: Cxt, option?: OperateOption) => Promise<number>;
+}
+export interface UpdateTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends UpdateTriggerBase<ED, T, Cxt> {
+    when: 'before' | 'after';
+}
+export interface UpdateTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends UpdateTriggerBase<ED, T, Cxt> {
+    when: 'commit';
+    strict?: 'takeEasy' | 'makeSure';
+}
+export declare type UpdateTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = UpdateTriggerInTxn<ED, T, Cxt> | UpdateTriggerCrossTxn<ED, T, Cxt>;
+export interface RemoveTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> {
+    checkerType?: CheckerType;
+    entity: T;
+    name: string;
+    action: 'remove';
+    check?: (operation: ED[T]['Remove']) => boolean;
+    fn: (event: {
+        operation: ED[T]['Remove'];
+    }, context: Cxt, option?: OperateOption) => Promise<number>;
+}
+export interface RemoveTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends RemoveTriggerBase<ED, T, Cxt> {
+    when: 'before' | 'after';
+}
+export interface RemoveTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends RemoveTriggerBase<ED, T, Cxt> {
+    when: 'commit';
+    strict?: 'takeEasy' | 'makeSure';
+}
+export declare type RemoveTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = RemoveTriggerInTxn<ED, T, Cxt> | RemoveTriggerCrossTxn<ED, T, Cxt>;
+export interface SelectTriggerBase<ED extends EntityDict, T extends keyof ED> {
+    checkerType?: undefined;
+    entity: T;
+    name: string;
+    action: 'select';
+}
+/**
+ * selection似乎不需要支持跨事务？没想清楚
+ * todo by Xc
+ */
+export interface SelectTriggerBefore<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends SelectTriggerBase<ED, T> {
+    when: 'before';
+    fn: (event: {
+        operation: ED[T]['Selection'];
+    }, context: Cxt, params?: SelectOption) => Promise<number>;
+}
+export interface SelectTriggerAfter<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends SelectTriggerBase<ED, T> {
+    when: 'after';
+    fn: (event: {
+        operation: ED[T]['Selection'];
+        result: SelectRowShape<ED[T]['Schema'], ED[T]['Selection']['data']>[];
+    }, context: Cxt, params?: SelectOption) => Promise<number>;
+}
+export declare type SelectTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = SelectTriggerBefore<ED, T, Cxt> | SelectTriggerAfter<ED, T, Cxt>;
+export declare type Trigger<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = CreateTrigger<ED, T, Cxt> | UpdateTrigger<ED, T, Cxt> | RemoveTrigger<ED, T, Cxt> | SelectTrigger<ED, T, Cxt>;
+export interface TriggerEntityShape extends EntityShape {
+    $$triggerData$$?: {
+        name: string;
+        operation: object;
+    };
+    $$triggerTimestamp$$?: number;
+}
+export declare abstract class Executor<ED extends EntityDict, Cxt extends Context<ED>> {
+    static dataAttr: TriggerDataAttribute;
+    static timestampAttr: TriggerTimestampAttribute;
+    abstract registerTrigger<T extends keyof ED>(trigger: Trigger<ED, T, Cxt>): void;
+    abstract preOperation<T extends keyof ED>(entity: T, operation: ED[T]['Operation'] | ED[T]['Selection'] & {
+        action: 'select';
+    }, context: Cxt, option?: OperateOption | SelectOption): Promise<void>;
+    abstract postOperation<T extends keyof ED>(entity: T, operation: ED[T]['Operation'] | ED[T]['Selection'] & {
+        action: 'select';
+    }, context: Cxt, option?: OperateOption | SelectOption, result?: SelectRowShape<ED[T]['Schema'], ED[T]['Selection']['data']>[]): Promise<void>;
+    abstract checkpoint(context: Cxt, timestamp: number): Promise<number>;
+}

package/lib/types/Trigger.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Executor = void 0;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+;
+var Executor = /** @class */ (function () {
+    function Executor() {
+    }
+    Executor.dataAttr = '$$triggerData$$';
+    Executor.timestampAttr = '$$triggerTimestamp$$';
+    return Executor;
+}());
+exports.Executor = Executor;

package/lib/types/Txn.d.ts

@@ -0,0 +1,2 @@
+export interface Txn {
+}

package/lib/types/Txn.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/lib/types/Watcher.d.ts

@@ -0,0 +1,19 @@
+import { Context } from "./Context";
+import { EntityDict, OperationResult, SelectionResult } from "./Entity";
+declare type ActionData<ED extends EntityDict, T extends keyof ED> = ED[T]['Update']['data'] | ED[T]['Remove']['data'];
+export interface BBWatcher<ED extends EntityDict, T extends keyof ED> {
+    name: string;
+    entity: T;
+    filter: ED[T]['Selection']['filter'] | (() => Promise<ED[T]['Selection']['filter']>);
+    action: ED[T]['Operation']['action'];
+    actionData: ActionData<ED, T> | (() => Promise<ActionData<ED, T>>);
+}
+export interface WBWatcher<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> {
+    name: string;
+    entity: T;
+    filter: ED[T]['Selection']['filter'] | (() => Promise<ED[T]['Selection']['filter']>);
+    projection: ED[T]['Selection']['data'] | (() => Promise<ED[T]['Selection']['data']>);
+    fn: (context: Cxt, data: SelectionResult<ED[T]['Schema'], Required<this['projection']>>['result']) => Promise<OperationResult<ED>>;
+}
+export declare type Watcher<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = BBWatcher<ED, T> | WBWatcher<ED, T, Cxt>;
+export {};

package/lib/types/Watcher.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+;

package/lib/types/index.d.ts

@@ -0,0 +1,18 @@
+export * from './Action';
+export * from './Aspect';
+export * from './Auth';
+export * from './Context';
+export * from './DataType';
+export * from './Demand';
+export * from './Entity';
+export * from './Expression';
+export * from './Geo';
+export * from './Logger';
+export * from './Polyfill';
+export * from './RowStore';
+export * from './Storage';
+export * from './Trigger';
+export * from './Exception';
+export * from './Watcher';
+export * from './AppLoader';
+export * from './Connector';

package/lib/types/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Action"), exports);
+__exportStar(require("./Aspect"), exports);
+__exportStar(require("./Auth"), exports);
+__exportStar(require("./Context"), exports);
+__exportStar(require("./DataType"), exports);
+__exportStar(require("./Demand"), exports);
+__exportStar(require("./Entity"), exports);
+__exportStar(require("./Expression"), exports);
+__exportStar(require("./Geo"), exports);
+__exportStar(require("./Logger"), exports);
+__exportStar(require("./Polyfill"), exports);
+__exportStar(require("./RowStore"), exports);
+__exportStar(require("./Storage"), exports);
+__exportStar(require("./Trigger"), exports);
+__exportStar(require("./Exception"), exports);
+__exportStar(require("./Watcher"), exports);
+__exportStar(require("./AppLoader"), exports);
+__exportStar(require("./Connector"), exports);

package/lib/types/schema/DataTypes.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Column types used for @PrimaryGeneratedColumn() decorator.
+ */
+export declare type PrimaryGeneratedColumnType = "int" | "int2" | "int4" | "int8" | "integer" | "tinyint" | "smallint" | "mediumint" | "bigint" | "dec" | "decimal" | "smalldecimal" | "fixed" | "numeric" | "number";
+/**
+ * Column types where spatial properties are used.
+ */
+export declare type SpatialColumnType = "geometry" | "geography" | "st_geometry" | "st_point";
+/**
+ * Column types where precision and scale properties are used.
+ */
+export declare type WithPrecisionColumnType = "float" | "double" | "dec" | "decimal" | "smalldecimal" | "fixed" | "numeric" | "real" | "double precision" | "number" | "datetime" | "datetime2" | "datetimeoffset" | "time" | "time with time zone" | "time without time zone" | "timestamp" | "timestamp without time zone" | "timestamp with time zone" | "timestamp with local time zone";
+/**
+ * Column types where column length is used.
+ */
+export declare type WithLengthColumnType = "character varying" | "varying character" | "char varying" | "nvarchar" | "national varchar" | "character" | "native character" | "varchar" | "char" | "nchar" | "national char" | "varchar2" | "nvarchar2" | "alphanum" | "shorttext" | "raw" | "binary" | "varbinary" | "string";
+export declare type WithWidthColumnType = "tinyint" | "smallint" | "mediumint" | "int" | "bigint";
+/**
+ * All other regular column types.
+ */
+export declare type SimpleColumnType = "simple-array" | "simple-json" | "simple-enum" | "int2" | "integer" | "int4" | "int8" | "int64" | "unsigned big int" | "float" | "float4" | "float8" | "smallmoney" | "money" | "boolean" | "bool" | "tinyblob" | "tinytext" | "mediumblob" | "mediumtext" | "blob" | "text" | "ntext" | "citext" | "hstore" | "longblob" | "longtext" | "alphanum" | "shorttext" | "bytes" | "bytea" | "long" | "raw" | "long raw" | "bfile" | "clob" | "nclob" | "image" | "timetz" | "timestamptz" | "timestamp with local time zone" | "smalldatetime" | "date" | "interval year to month" | "interval day to second" | "interval" | "year" | "seconddate" | "point" | "line" | "lseg" | "box" | "circle" | "path" | "polygon" | "geography" | "geometry" | "linestring" | "multipoint" | "multilinestring" | "multipolygon" | "geometrycollection" | "st_geometry" | "st_point" | "int4range" | "int8range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "enum" | "set" | "cidr" | "inet" | "macaddr" | "bit" | "bit varying" | "varbit" | "tsvector" | "tsquery" | "uuid" | "xml" | "json" | "jsonb" | "varbinary" | "hierarchyid" | "sql_variant" | "rowid" | "urowid" | "uniqueidentifier" | "rowversion" | "array" | "cube" | "ltree" | "object" | "array" | "function";
+/**
+ * Any column type column can be.
+ */
+export declare type DataType = WithPrecisionColumnType | WithLengthColumnType | WithWidthColumnType | SpatialColumnType | SimpleColumnType;
+export interface DataTypeParams {
+    length?: number;
+    width?: number;
+    precision?: number;
+    scale?: number;
+    signed?: boolean;
+}

package/lib/types/schema/DataTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/lib/utils/SimpleConnector.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders } from "http";
+import { UniversalContext } from "../store/UniversalContext";
+import { Connector, EntityDict, OakException, OpRecord, RowStore } from "../types";
+export declare class SimpleConnector<ED extends EntityDict, Cxt extends UniversalContext<ED>> extends Connector<ED, Cxt> {
+    static ROUTER: string;
+    private serverUrl;
+    private makeException;
+    private contextBuilder;
+    constructor(serverUrl: string, makeException: (exceptionData: any) => OakException, contextBuilder: (str: string | undefined) => (store: RowStore<ED, Cxt>) => Cxt);
+    callAspect(name: string, params: any, context: Cxt): Promise<{
+        result: any;
+        opRecords: OpRecord<ED>[];
+    }>;
+    getRouter(): string;
+    parseRequest(headers: IncomingHttpHeaders, body: any, store: RowStore<ED, Cxt>): {
+        name: string;
+        params: any;
+        context: Cxt;
+    };
+    serializeResult(result: any, context: Cxt, headers: IncomingHttpHeaders, body: any): {
+        body: any;
+        headers?: Record<string, any> | undefined;
+    };
+    serializeException(exception: OakException, headers: IncomingHttpHeaders, body: any): {
+        body: any;
+        headers?: Record<string, any> | undefined;
+    };
+}

package/lib/utils/SimpleConnector.js

@@ -0,0 +1,145 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleConnector = void 0;
+var assert_1 = __importDefault(require("assert"));
+var types_1 = require("../types");
+function makeContentTypeAndBody(data) {
+    return {
+        contentType: 'application/json',
+        body: JSON.stringify(data),
+    };
+}
+var SimpleConnector = /** @class */ (function (_super) {
+    __extends(SimpleConnector, _super);
+    function SimpleConnector(serverUrl, makeException, contextBuilder) {
+        var _this = _super.call(this) || this;
+        _this.serverUrl = "".concat(serverUrl).concat(SimpleConnector.ROUTER);
+        _this.makeException = makeException;
+        _this.contextBuilder = contextBuilder;
+        return _this;
+    }
+    SimpleConnector.prototype.callAspect = function (name, params, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cxtStr, _a, contentType, body, response, err, _b, exception, result, opRecords;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, context.toString()];
+                    case 1:
+                        cxtStr = _c.sent();
+                        _a = makeContentTypeAndBody(params), contentType = _a.contentType, body = _a.body;
+                        return [4 /*yield*/, global.fetch(this.serverUrl, {
+                                method: 'POST',
+                                headers: {
+                                    'Content-Type': contentType,
+                                    'oak-cxt': cxtStr,
+                                    'oak-aspect': name,
+                                },
+                                body: body,
+                            })];
+                    case 2:
+                        response = _c.sent();
+                        if (response.status > 299) {
+                            err = new types_1.OakExternalException("\u7F51\u7EDC\u8BF7\u6C42\u8FD4\u56DE\u5F02\u5E38\uFF0Cstatus\u662F".concat(response.status));
+                            throw err;
+                        }
+                        return [4 /*yield*/, response.json()];
+                    case 3:
+                        _b = _c.sent(), exception = _b.exception, result = _b.result, opRecords = _b.opRecords;
+                        if (exception) {
+                            throw this.makeException(exception);
+                        }
+                        return [2 /*return*/, {
+                                result: result,
+                                opRecords: opRecords,
+                            }];
+                }
+            });
+        });
+    };
+    SimpleConnector.prototype.getRouter = function () {
+        return SimpleConnector.ROUTER;
+    };
+    SimpleConnector.prototype.parseRequest = function (headers, body, store) {
+        var oakCxtStr = headers["oak-cxt"], aspectName = headers["oak-aspect"];
+        (0, assert_1.default)(typeof oakCxtStr === 'string' || oakCxtStr === undefined);
+        (0, assert_1.default)(typeof aspectName === 'string');
+        var context = this.contextBuilder(oakCxtStr)(store);
+        return {
+            name: aspectName,
+            params: body,
+            context: context,
+        };
+    };
+    SimpleConnector.prototype.serializeResult = function (result, context, headers, body) {
+        return {
+            body: {
+                result: result,
+                opRecords: context.opRecords,
+            },
+        };
+    };
+    SimpleConnector.prototype.serializeException = function (exception, headers, body) {
+        return {
+            body: {
+                exception: exception.toString(),
+            },
+        };
+    };
+    SimpleConnector.ROUTER = '/aspect';
+    return SimpleConnector;
+}(types_1.Connector));
+exports.SimpleConnector = SimpleConnector;

package/lib/utils/assert.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 防止assert打包体积过大，从这里引用
+ */
+import assert from 'assert';
+export { assert, };

package/lib/utils/assert.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+/**
+ * 防止assert打包体积过大，从这里引用
+ */
+var assert_1 = __importDefault(require("assert"));
+exports.assert = assert_1.default;