oak-domain 2.2.0 → 2.3.0

package/lib/store/filter.d.ts

@@ -97,3 +97,4 @@ export declare function makeTreeAncestorFilter<ED extends EntityDict, T extends
  */
 export declare function makeTreeDescendantFilter<ED extends EntityDict, T extends keyof ED>(entity: T, parentKey: string, filter: ED[T]['Selection']['filter'], level?: number, includeAll?: boolean, includeSelf?: boolean): ED[T]['Selection']['filter'];
 export declare function checkFilterContains<ED extends EntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, contained: ED[T]['Selection']['filter'], filter?: ED[T]['Selection']['filter']): boolean | Promise<boolean>;
+export declare function checkFilterRepel<ED extends EntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter']): boolean | Promise<boolean>;

package/lib/store/filter.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkFilterContains = exports.makeTreeDescendantFilter = exports.makeTreeAncestorFilter = exports.same = exports.getRelevantIds = exports.repel = exports.contains = exports.judgeValueRelation = exports.combineFilters = exports.unionFilterSegment = exports.addFilterSegment = void 0;
+exports.checkFilterRepel = exports.checkFilterContains = exports.makeTreeDescendantFilter = exports.makeTreeAncestorFilter = exports.same = exports.getRelevantIds = exports.repel = exports.contains = exports.judgeValueRelation = exports.combineFilters = exports.unionFilterSegment = exports.addFilterSegment = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
 var types_1 = require("../types");
@@ -502,7 +502,7 @@ function judgeFilter2ValueRelation(entity, schema, attr, filter, conditionalFilt
                     var logicQueries = filter[attr2];
                     var results = logicQueries.map(function (logicQuery) { return judgeFilter2ValueRelation(entity, schema, attr, logicQuery, conditionalFilterAttrValue, contained); });
                     // 如果filter的多个算子是and关系，则只要有一个包含此条件就是包含，只要有一个与此条件相斥就是相斥
-                    // 如果filter的多个算子是or关系，则必须所有的条件都包含此条件才是包含，必须所有的条件都与此条件相斥才是相斥
+                    // 如果filter的多个算子是or关系，则必须所有的条件都包含此条件才是包含，必须所有的条件都与此条件相斥才是相斥                    
                     if (attr2 === '$and') {
                         if (results.includes(true)) {
                             return true;
@@ -520,25 +520,17 @@ function judgeFilter2ValueRelation(entity, schema, attr, filter, conditionalFilt
                 }
                 case '$not': {
                     /*
-                    * 若filter的not条件被conditionalFilterAttrValue包容，则说明两者互斥
-                    * 若filter的not条件被conditionalFilterAttrValue的not条件所包容，则说明此条件包容conditionalFilterAttrValue
-                    *   但两条规则都没法应用，会无限递归
+                    * 若filter的not条件被conditionalFilterAttrValue条件包容，则说明两者互斥
+                    * filter包容conditionalFilterAttrValue条件暂时无法由其not条件推论出来
                     */
                     var logicQuery = filter[attr2];
-                    /* if (contained && judgeFilterRelation(entity, schema, {
-                        [attr2]: {
-                            $not: conditionalFilterAttrValue
-                        }
-                    }, logicQuery, contained)) {
-                        return true;
-                    } */
-                    if (!contained && judgeFilterRelation(entity, schema, (_a = {}, _a[attr2] = conditionalFilterAttrValue, _a), logicQuery, contained)) {
+                    if (!contained && judgeFilterRelation(entity, schema, logicQuery, (_a = {}, _a[attr] = conditionalFilterAttrValue, _a), true)) {
                         return true;
                     }
                     break;
                 }
                 default: {
-                    break;
+                    (0, assert_1.default)(false);
                 }
             }
         }
@@ -566,6 +558,7 @@ function judgeFilter2ValueRelation(entity, schema, attr, filter, conditionalFilt
             }
         }
     }
+    // 到这里说明无法判断相容或者相斥，安全起见全返回false
     return false;
 }
 /**
@@ -584,15 +577,15 @@ function judgeFilterRelation(entity, schema, filter, conditionalFilter, containe
                     var logicQueries = conditionalFilter[attr];
                     var results = logicQueries.map(function (logicQuery) { return judgeFilterRelation(entity, schema, filter, logicQuery, contained); });
                     if (contained) {
-                        // 如果是包容关系，则无论and还是or，conditionalFilter中的任何一个查询条件都应当被filter所包容
+                        // 如果是包容关系，or和and需要全部被包容
                         if (results.includes(false)) {
                             return false;
                         }
                     }
                     else if (!contained) {
-                        // 如果是相斥关系，则无论and还是or，conditionalFilter中的任何一个查询条件都应当与filter所相斥
-                        if (!results.includes(true)) {
-                            return false;
+                        // 如果是相斥关系，and只需要和一个相斥，or需要和全部相斥
+                        if (attr === '$and' && results.includes(true) || attr === '$or' && !results.includes(false)) {
+                            return true;
                         }
                     }
                     else {
@@ -602,12 +595,19 @@ function judgeFilterRelation(entity, schema, filter, conditionalFilter, containe
                 }
                 case '$not': {
                     /**
-                     * 若filter与not所定义的filter相斥，则filter与conditionalFilter相容
-                     * 若filter与not所定义的filter相容，则filter与conditionalFilter相斥
+                     * 若filter与conditionalFilter not所定义的部分相斥，则filter与conditionalFilter相容
+                     * 若filter将conditionalFilter not所定义的部分包容，则filter与conditionalFilter相斥
                      */
                     var logicQuery = conditionalFilter[attr];
-                    if (judgeFilterRelation(entity, schema, filter, logicQuery, !contained)) {
-                        return true;
+                    if (contained) {
+                        if (!judgeFilterRelation(entity, schema, filter, logicQuery, false)) {
+                            return false;
+                        }
+                    }
+                    else {
+                        if (judgeFilterRelation(entity, schema, filter, logicQuery, true)) {
+                            return true;
+                        }
                     }
                     break;
                 }
@@ -655,8 +655,8 @@ function judgeFilterRelation(entity, schema, filter, conditionalFilter, containe
  * @returns
  */
 function contains(entity, schema, filter, conditionalFilter) {
-    // return judgeFilterRelation(entity, schema, filter, conditionalFilter, true);
-    return false;
+    return judgeFilterRelation(entity, schema, filter, conditionalFilter, true);
+    // return false;
 }
 exports.contains = contains;
 /**
@@ -675,8 +675,8 @@ exports.contains = contains;
  */
 function repel(entity, schema, filter1, filter2) {
     // todo
-    // return judgeFilterRelation(entity, schema, filter1, filter2, false);
-    return false;
+    return judgeFilterRelation(entity, schema, filter1, filter2, false);
+    // return false;
 }
 exports.repel = repel;
 /**
@@ -853,3 +853,26 @@ function checkFilterContains(entity, context, contained, filter) {
     return count === 0;
 }
 exports.checkFilterContains = checkFilterContains;
+function checkFilterRepel(entity, context, filter1, filter2) {
+    if (!filter2) {
+        throw new types_1.OakRowInconsistencyException();
+    }
+    var schema = context.getSchema();
+    // 优先判断两个条件是否相容
+    if (repel(entity, schema, filter2, filter1)) {
+        return true;
+    }
+    // 再判断两者同时成立时取得的行数是否为0
+    var filter3 = combineFilters([filter2, filter1]);
+    var count = context.count(entity, {
+        filter: filter3,
+    }, {
+        dontCollect: true,
+        blockTrigger: true,
+    });
+    if (count instanceof Promise) {
+        return count.then(function (count2) { return count2 !== 0; });
+    }
+    return count !== 0;
+}
+exports.checkFilterRepel = checkFilterRepel;

package/lib/store/relation.js

@@ -24,9 +24,11 @@ function judgeRelation(schema, entity, attr) {
         return 1;
     }
     if (attr.includes('$')) {
-        var entity2 = attr.slice(0, attr.indexOf('$'));
+        var firstDelimiter = attr.indexOf('$');
+        var entity2 = attr.slice(0, firstDelimiter);
         (0, assert_1.default)(schema.hasOwnProperty(entity2));
-        var foreignKey = attr.slice(attr.indexOf('$') + 1);
+        var secondDelemiter = attr.indexOf('$', firstDelimiter + 1);
+        var foreignKey = attr.slice(firstDelimiter + 1, secondDelemiter > 0 ? secondDelemiter : attr.length);
         var _c = schema, _d = entity2, attributes2 = _c[_d].attributes;
         if (foreignKey === 'entity') {
             // 基于反指对象的反向关联

package/lib/store/selection.js

@@ -181,7 +181,7 @@ function reinforceSelection(schema, entity, selection) {
                         necessaryAttrs.push("".concat(attr, "Id"));
                         checkProjectionNode(rel, projectionNode[attr]);
                     }
-                    else if (rel instanceof Array) {
+                    else if (rel instanceof Array && !attr.endsWith('$$aggr')) {
                         var data_1 = projectionNode[attr].data;
                         if (rel[1]) {
                             checkNode(data_1, [rel[1]]);
@@ -189,7 +189,7 @@ function reinforceSelection(schema, entity, selection) {
                         else {
                             checkNode(data_1, ['entity', 'entityId']);
                         }
-                        checkProjectionNode(rel[0], data_1);
+                        reinforceSelection(schema, rel[0], projectionNode[attr]);
                     }
                 }
             }

package/lib/types/Auth.d.ts

@@ -3,12 +3,17 @@ import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption, SelectOption } from "../types/Entity";
 import { RefOrExpression } from "./Expression";
 export declare type CheckerType = 'relation' | 'row' | 'data' | 'expression' | 'expressionRelation';
+/**
+ * conditionalFilter是指该action发生时，operation所操作的行中有满足conditionalFilter的行
+ * 被转化成trigger的filter条件，详细可看trigger中的说明
+ */
 export declare type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'data';
     entity: T;
     action: Omit<ED[T]['Action'], 'remove'> | Array<Omit<ED[T]['Action'], 'remove'>>;
     checker: (data: ED[T]['Create']['data'] | ED[T]['Update']['data'], context: Cxt) => void;
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
@@ -21,6 +26,7 @@ export declare type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt ex
         entity: keyof ED;
         selection: (filter?: ED[T]['Selection']['filter']) => ED[keyof ED]['Selection'];
     };
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type RelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
@@ -29,6 +35,7 @@ export declare type RelationChecker<ED extends EntityDict, T extends keyof ED, C
     action: Omit<ED[T]['Action'], 'create'> | Array<Omit<ED[T]['Action'], 'create'>>;
     relationFilter: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => ED[T]['Selection']['filter'];
     errMsg: string;
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type ExpressionChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
@@ -39,8 +46,9 @@ export declare type ExpressionChecker<ED extends EntityDict, T extends keyof ED,
         entity: T2;
         expr: RefOrExpression<keyof ED[T2]['OpSchema']>;
         filter: ED[T2]['Selection']['filter'];
-    };
+    } | undefined | string;
     errMsg: string;
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type ExpressionRelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
@@ -51,7 +59,8 @@ export declare type ExpressionRelationChecker<ED extends EntityDict, T extends k
         entity: T2;
         expr: RefOrExpression<keyof ED[T2]['OpSchema']>;
         filter: ED[T2]['Selection']['filter'];
-    };
+    } | undefined | string;
     errMsg: string;
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type Checker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = DataChecker<ED, T, Cxt> | RowChecker<ED, T, Cxt> | RelationChecker<ED, T, Cxt> | ExpressionChecker<ED, T, Cxt> | ExpressionRelationChecker<ED, T, Cxt>;

package/lib/types/Entity.d.ts

@@ -73,6 +73,7 @@ export interface EntityDef {
     Action: string;
     ParticularAction?: string;
     Selection: Omit<DeduceSelection<this['Schema']>, 'action'>;
+    Aggregation: Omit<DeduceAggregation<this['Schema'], DeduceProjection<this['Schema']>, DeduceFilter<this['Schema']>, DeduceSorter<this['Schema']>>, 'action'>;
     Operation: DeduceOperation<this['Schema']>;
     Create: DeduceCreateOperation<this['Schema']>;
     CreateSingle: DeduceCreateSingleOperation<this['Schema']>;
@@ -90,7 +91,18 @@ declare type DeduceProjection<SH extends GeneralEntityShape> = {
     '#id'?: NodeId;
 } & {
     [K in keyof SH]?: number | OtmSubProjection | any;
-} & Partial<ExprOp<keyof SH>>;
+} & Partial<ExprOp<keyof SH | string>>;
+export declare type AggregationOp = `#max-${number}` | `#min-${number}` | `#avg-${number}` | `#count-${number}` | `#sum-${number}`;
+export declare type DeduceAggregationData<SH extends GeneralEntityShape, P extends DeduceProjection<SH>> = {
+    [A in AggregationOp]?: P;
+} & {
+    '#aggr'?: P;
+};
+export declare type AggregationResult<SH extends GeneralEntityShape> = Array<{
+    [A in AggregationOp]?: number | string;
+} & {
+    '#data'?: Partial<SH>;
+}>;
 export declare type AttrFilter<SH extends GeneralEntityShape> = {
     [K in keyof SH]: any;
 };
@@ -104,6 +116,7 @@ export declare type DeduceSorterItem<SH extends GeneralEntityShape> = {
 };
 export declare type DeduceSorter<SH extends GeneralEntityShape> = Array<DeduceSorterItem<SH>>;
 export declare type DeduceSelection<SH extends GeneralEntityShape> = Selection<DeduceProjection<SH>, DeduceFilter<SH>, DeduceSorter<SH>>;
+export declare type DeduceAggregation<SH extends GeneralEntityShape, P extends DeduceProjection<SH>, F extends DeduceFilter<SH>, S extends DeduceSorter<SH>> = Omit<Operation<'aggregate', DeduceAggregationData<SH, P>, F, S>, 'action'>;
 export declare type DeduceCreateOperationData<SH extends GeneralEntityShape> = {
     id: string;
 } & {
@@ -137,6 +150,9 @@ export declare type RemoveOpResult<ED extends EntityDict, T extends keyof ED> =
     e: T;
     f?: DeduceFilter<ED[T]['Schema']>;
 };
+export declare type RelationHierarchy<R extends string> = {
+    [K in R]?: R[];
+};
 export declare type SelectOpResult<ED extends EntityDict> = {
     a: 's';
     d: {
@@ -156,4 +172,19 @@ export declare type Configuration = {
     actionType?: ActionType;
     static?: boolean;
 };
+export declare type Exportation<ED extends EntityDict, T extends keyof ED, K extends string> = {
+    name: string;
+    id: string;
+    entity: T;
+    projection: ED[T]['Selection']['data'];
+    headers: K[];
+    fn: (data: ED[T]['Schema']) => Partial<Record<K, string | number | boolean | null>>;
+};
+export declare type Importation<ED extends EntityDict, T extends keyof ED, K extends string> = {
+    name: string;
+    id: string;
+    entity: T;
+    headers: K[];
+    fn: (data: Partial<Record<K, string | number | boolean>>) => ED[T]['CreateSingle']['data'];
+};
 export {};

package/lib/types/Expression.js

@@ -361,7 +361,7 @@ function getAttrRefInExpression(expression) {
         _a['#current'] = [],
         _a);
     var check = function (node) {
-        var _a;
+        var _a, e_3, _b;
         if (node['#attr']) {
             result['#current'].push(node['#attr']);
         }
@@ -375,9 +375,24 @@ function getAttrRefInExpression(expression) {
                     _a));
             }
         }
-        else {
-            for (var attr in expression) {
-                check(expression[attr]);
+        else if (node instanceof Array) {
+            try {
+                for (var node_1 = tslib_1.__values(node), node_1_1 = node_1.next(); !node_1_1.done; node_1_1 = node_1.next()) {
+                    var subNode = node_1_1.value;
+                    check(subNode);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (node_1_1 && !node_1_1.done && (_b = node_1.return)) _b.call(node_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+        else if (typeof node === 'object') {
+            for (var attr in node) {
+                check(node[attr]);
             }
         }
     };

package/lib/types/Storage.d.ts

@@ -1,5 +1,5 @@
 import { ActionType } from '.';
-import { EntityDict, EntityShape, InstinctiveAttributes } from './Entity';
+import { EntityDict, EntityShape, InstinctiveAttributes, RelationHierarchy } from './Entity';
 import { DataType, DataTypeParams } from './schema/DataTypes';
 export declare type Ref = 'ref';
 export interface Column<SH extends EntityShape> {
@@ -36,7 +36,7 @@ export declare type UniqConstraint<SH extends EntityShape> = {
     attributes: Array<keyof SH>;
     type?: string;
 };
-export interface StorageDesc<SH extends EntityShape> {
+export interface StorageDesc<SH extends EntityShape, Relation extends string = ''> {
     storageName?: string;
     comment?: string;
     attributes: Attributes<SH>;
@@ -48,8 +48,9 @@ export interface StorageDesc<SH extends EntityShape> {
     static?: true;
     actions: string[];
     actionType: ActionType;
+    relationHierarchy?: RelationHierarchy<Relation>;
     view?: true;
 }
 export declare type StorageSchema<ED extends EntityDict> = {
-    [K in keyof ED]: StorageDesc<ED[K]['OpSchema']>;
+    [K in keyof ED]: StorageDesc<ED[K]['OpSchema'], any>;
 };

package/lib/types/Timer.d.ts

@@ -1,4 +1,3 @@
-import { RecurrenceRule, RecurrenceSpecDateRange, RecurrenceSpecObjLit } from 'node-schedule';
 import { EntityDict } from './Entity';
 import { AsyncContext } from "../store/AsyncRowStore";
 declare type RoutineFn<ED extends EntityDict, Cxt extends AsyncContext<ED>> = (context: Cxt) => Promise<string>;
@@ -8,7 +7,7 @@ export declare type Routine<ED extends EntityDict, Cxt extends AsyncContext<ED>>
 };
 export declare type Timer<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
     name: string;
-    cron: RecurrenceRule | RecurrenceSpecDateRange | RecurrenceSpecObjLit | Date | string | number;
+    cron: string;
     fn: RoutineFn<ED, Cxt>;
 };
 export {};

package/lib/types/Trigger.d.ts

@@ -25,6 +25,11 @@ export interface CreateTriggerCrossTxn<ED extends EntityDict, T extends keyof ED
     strict?: 'takeEasy' | 'makeSure';
 }
 export declare type CreateTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = CreateTriggerInTxn<ED, T, Cxt> | CreateTriggerCrossTxn<ED, T, Cxt>;
+/**
+ * update trigger如果带有filter，说明只对存在限定条件的行起作用。此时系统在进行相应动作时，
+ * 会判定当前动作的filter条件和trigger所定义的filter是否有交集（即有同时满足两个条件的行）
+ * 只要有，就会触发trigger。要注意的是这个条件是exists而不是all
+ */
 export interface UpdateTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
     action: Exclude<ED[T]['Action'], GenericAction> | 'update' | Array<Exclude<ED[T]['Action'], GenericAction> | 'update'>;
     attributes?: keyof ED[T]['OpSchema'] | Array<keyof ED[T]['OpSchema']>;
@@ -32,6 +37,7 @@ export interface UpdateTriggerBase<ED extends EntityDict, T extends keyof ED, Cx
     fn: (event: {
         operation: ED[T]['Update'];
     }, context: Cxt, option: OperateOption) => Promise<number> | number;
+    filter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Update'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 }
 export interface UpdateTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends UpdateTriggerBase<ED, T, Cxt> {
     when: 'before' | 'after';
@@ -41,12 +47,18 @@ export interface UpdateTriggerCrossTxn<ED extends EntityDict, T extends keyof ED
     strict?: 'takeEasy' | 'makeSure';
 }
 export declare type UpdateTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = UpdateTriggerInTxn<ED, T, Cxt> | UpdateTriggerCrossTxn<ED, T, Cxt>;
+/**
+ * 同update trigger一样，remove trigger如果带有filter，说明只对存在限定条件的行起作用。此时系统在进行相应动作时，
+ * 会判定当前动作的filter条件和trigger所定义的filter是否有交集（即有同时满足两个条件的行）
+ * 只要有，就会触发trigger。要注意的是这个条件是exists而不是all
+ */
 export interface RemoveTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
     action: 'remove';
     check?: (operation: ED[T]['Remove']) => boolean;
     fn: (event: {
         operation: ED[T]['Remove'];
     }, context: Cxt, option: OperateOption) => Promise<number> | number;
+    filter?: ED[T]['Remove']['filter'] | ((operation: ED[T]['Remove'], context: Cxt, option: OperateOption) => ED[T]['Remove']['filter']);
 }
 export interface RemoveTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends RemoveTriggerBase<ED, T, Cxt> {
     when: 'before' | 'after';

package/lib/utils/SimpleConnector.js

@@ -3,8 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleConnector = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
+var stream_1 = require("stream");
 var types_1 = require("../types");
 function makeContentTypeAndBody(data) {
+    //
+    if (process.env.OAK_PLATFORM !== 'wechatMp') {
+        if (data instanceof FormData) {
+            return {
+                contentType: 'multipart/form-data',
+                body: data,
+            };
+        }
+    }
     return {
         contentType: 'application/json',
         body: JSON.stringify(data),
@@ -82,6 +92,11 @@ var SimpleConnector = /** @class */ (function (_super) {
         });
     };
     SimpleConnector.prototype.serializeResult = function (result, context, headers, body) {
+        if (result instanceof stream_1.Stream) {
+            return {
+                body: result,
+            };
+        }
         return {
             body: {
                 result: result,

package/lib/utils/cron.d.ts

@@ -0,0 +1 @@
+export declare function schedule(cron: string, fn: (date: Date) => any): void;

package/lib/utils/cron.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schedule = void 0;
+var tslib_1 = require("tslib");
+var cronjs_matcher_1 = require("@datasert/cronjs-matcher");
+var dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+function schedule(cron, fn) {
+    var futureMatches = (0, cronjs_matcher_1.getFutureMatches)(cron, {
+        matchCount: 1,
+    });
+    var date = (0, dayjs_1.default)(futureMatches[0]);
+    var interval = date.diff((0, dayjs_1.default)(), 'ms');
+    setTimeout(function () {
+        fn(new Date());
+        schedule(cron, fn);
+    }, interval);
+}
+exports.schedule = schedule;

package/lib/utils/lodash.d.ts

@@ -2,4 +2,19 @@
  * 避免lodash打包体积过大
  * 像assign, keys尽量使用Object的函数
  */
-export { unset, pull, uniq, uniqBy, get, set, intersection, omit, merge, cloneDeep, pick, isEqual, union, difference, groupBy, } from 'lodash';
+import unset from 'lodash/unset';
+import uniqBy from 'lodash/uniqBy';
+import pull from 'lodash/pull';
+import uniq from 'lodash/uniq';
+import get from 'lodash/get';
+import set from 'lodash/set';
+import intersection from 'lodash/intersection';
+import omit from 'lodash/omit';
+import merge from 'lodash/merge';
+import cloneDeep from 'lodash/cloneDeep';
+import pick from 'lodash/pick';
+import isEqual from 'lodash/isEqual';
+import union from 'lodash/union';
+import difference from 'lodash/difference';
+import groupBy from 'lodash/groupBy';
+export { unset, pull, uniq, uniqBy, get, set, intersection, omit, merge, cloneDeep, pick, isEqual, union, difference, groupBy, };

package/lib/utils/lodash.js

@@ -1,38 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupBy = exports.difference = exports.union = exports.isEqual = exports.pick = exports.cloneDeep = exports.merge = exports.omit = exports.intersection = exports.set = exports.get = exports.uniqBy = exports.uniq = exports.pull = exports.unset = void 0;
+var tslib_1 = require("tslib");
 /**
  * 避免lodash打包体积过大
  * 像assign, keys尽量使用Object的函数
  */
-/* import unset from 'lodash/unset';
-import uniqBy from 'lodash/uniqBy';
-import pull from 'lodash/pull';
-import uniq from 'lodash/uniq';
-import get from 'lodash/get';
-import set from 'lodash/set';
-import intersection from 'lodash/intersection';
-import omit from 'lodash/omit';
-import merge from 'lodash/merge';
-import cloneDeep from 'lodash/cloneDeep';
-import pick from 'lodash/pick';
-import isEqual from 'lodash/isEqual';
-import union from 'lodash/union';
-import difference from 'lodash/difference';
-import groupBy from 'lodash/groupBy'; */
-var lodash_1 = require("lodash");
-Object.defineProperty(exports, "unset", { enumerable: true, get: function () { return lodash_1.unset; } });
-Object.defineProperty(exports, "pull", { enumerable: true, get: function () { return lodash_1.pull; } });
-Object.defineProperty(exports, "uniq", { enumerable: true, get: function () { return lodash_1.uniq; } });
-Object.defineProperty(exports, "uniqBy", { enumerable: true, get: function () { return lodash_1.uniqBy; } });
-Object.defineProperty(exports, "get", { enumerable: true, get: function () { return lodash_1.get; } });
-Object.defineProperty(exports, "set", { enumerable: true, get: function () { return lodash_1.set; } });
-Object.defineProperty(exports, "intersection", { enumerable: true, get: function () { return lodash_1.intersection; } });
-Object.defineProperty(exports, "omit", { enumerable: true, get: function () { return lodash_1.omit; } });
-Object.defineProperty(exports, "merge", { enumerable: true, get: function () { return lodash_1.merge; } });
-Object.defineProperty(exports, "cloneDeep", { enumerable: true, get: function () { return lodash_1.cloneDeep; } });
-Object.defineProperty(exports, "pick", { enumerable: true, get: function () { return lodash_1.pick; } });
-Object.defineProperty(exports, "isEqual", { enumerable: true, get: function () { return lodash_1.isEqual; } });
-Object.defineProperty(exports, "union", { enumerable: true, get: function () { return lodash_1.union; } });
-Object.defineProperty(exports, "difference", { enumerable: true, get: function () { return lodash_1.difference; } });
-Object.defineProperty(exports, "groupBy", { enumerable: true, get: function () { return lodash_1.groupBy; } });
+var unset_1 = tslib_1.__importDefault(require("lodash/unset"));
+exports.unset = unset_1.default;
+var uniqBy_1 = tslib_1.__importDefault(require("lodash/uniqBy"));
+exports.uniqBy = uniqBy_1.default;
+var pull_1 = tslib_1.__importDefault(require("lodash/pull"));
+exports.pull = pull_1.default;
+var uniq_1 = tslib_1.__importDefault(require("lodash/uniq"));
+exports.uniq = uniq_1.default;
+var get_1 = tslib_1.__importDefault(require("lodash/get"));
+exports.get = get_1.default;
+var set_1 = tslib_1.__importDefault(require("lodash/set"));
+exports.set = set_1.default;
+var intersection_1 = tslib_1.__importDefault(require("lodash/intersection"));
+exports.intersection = intersection_1.default;
+var omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+exports.omit = omit_1.default;
+var merge_1 = tslib_1.__importDefault(require("lodash/merge"));
+exports.merge = merge_1.default;
+var cloneDeep_1 = tslib_1.__importDefault(require("lodash/cloneDeep"));
+exports.cloneDeep = cloneDeep_1.default;
+var pick_1 = tslib_1.__importDefault(require("lodash/pick"));
+exports.pick = pick_1.default;
+var isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+exports.isEqual = isEqual_1.default;
+var union_1 = tslib_1.__importDefault(require("lodash/union"));
+exports.union = union_1.default;
+var difference_1 = tslib_1.__importDefault(require("lodash/difference"));
+exports.difference = difference_1.default;
+var groupBy_1 = tslib_1.__importDefault(require("lodash/groupBy"));
+exports.groupBy = groupBy_1.default;
+// export {
+//     unset,
+//     pull,
+//     uniq,
+//     uniqBy,
+//     get,
+//     set,
+//     intersection,
+//     omit,
+//     merge,
+//     cloneDeep,
+//     pick,
+//     isEqual,
+//     union,
+//     difference,
+//     groupBy,
+// } from 'lodash';

package/lib/utils/uuid.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateNewId = exports.setGenerateIdOption = exports.produceIds = exports.generateNewIdAsync = exports.expandUuidTo36Bytes = exports.shrinkUuidTo32Bytes = exports.sequentialUuid = void 0;
 var tslib_1 = require("tslib");
-var assert_1 = tslib_1.__importDefault(require("assert"));
 var uuid_1 = require("uuid");
 var random_1 = require("./random/random");
 var _nodeId;
@@ -172,11 +171,24 @@ function setGenerateIdOption(option) {
 }
 exports.setGenerateIdOption = setGenerateIdOption;
 function generateNewId() {
-    (0, assert_1.default)(ID_BUFFER.length > 0, '缓存的id已经用完，请提前调用produceIds以确保缓冲池中有足够的预分配id');
-    var id = ID_BUFFER.pop();
-    if (ID_BUFFER.length < 64) {
-        produceIds();
+    if (ID_BUFFER.length > 0) {
+        var id = ID_BUFFER.pop();
+        if (ID_BUFFER.length < 64) {
+            produceIds();
+        }
+        return id;
+    }
+    else {
+        // 如果没来的及填满缓冲池，这里用一个简单的算法产生同步id（在小程序环境下跑出来过）
+        var random = new Uint8Array(16);
+        var iter = 0;
+        do {
+            random[iter] = Math.ceil(Math.random() * 1000) % 128;
+        } while (++iter < 16);
+        if ((ID_OPTION === null || ID_OPTION === void 0 ? void 0 : ID_OPTION.shuffle) || process.env.NODE_ENV === 'development') {
+            return (0, uuid_1.v4)({ random: random });
+        }
+        return sequentialUuid({ random: random });
     }
-    return id;
 }
 exports.generateNewId = generateNewId;