oak-domain 1.1.14 → 2.0.2

package/lib/base-app-domain/Modi/Schema.d.ts

@@ -49,18 +49,18 @@ export declare type Filter = MakeFilter<AttrFilter & ExprOp<OpAttr | string>>;
 export declare type Projection = {
     "#id"?: NodeId;
     [k: string]: any;
-    id: 1;
-    $$createAt$$?: 1;
-    $$updateAt$$?: 1;
-    $$seq$$?: 1;
-    targetEntity?: 1;
-    entity?: 1;
-    entityId?: 1;
-    action?: 1;
-    data?: 1;
-    filter?: 1;
-    extra?: 1;
-    iState?: 1;
+    id: number;
+    $$createAt$$?: number;
+    $$updateAt$$?: number;
+    $$seq$$?: number;
+    targetEntity?: number;
+    entity?: number;
+    entityId?: number;
+    action?: number;
+    data?: number;
+    filter?: number;
+    extra?: number;
+    iState?: number;
     modiEntity$modi?: ModiEntity.Selection & {
         $entity: "modiEntity";
     };
@@ -91,26 +91,26 @@ export declare type ExportProjection = {
     };
 } & Partial<ExprOp<OpAttr | string>>;
 declare type ModiIdProjection = OneOf<{
-    id: 1;
+    id: number;
 }>;
 export declare type SortAttr = {
-    id: 1;
+    id: number;
 } | {
-    $$createAt$$: 1;
+    $$createAt$$: number;
 } | {
-    $$seq$$: 1;
+    $$seq$$: number;
 } | {
-    $$updateAt$$: 1;
+    $$updateAt$$: number;
 } | {
-    targetEntity: 1;
+    targetEntity: number;
 } | {
-    entity: 1;
+    entity: number;
 } | {
-    entityId: 1;
+    entityId: number;
 } | {
-    action: 1;
+    action: number;
 } | {
-    iState: 1;
+    iState: number;
 } | {
     [k: string]: any;
 } | OneOf<ExprOp<OpAttr | string>>;

package/lib/base-app-domain/ModiEntity/Schema.d.ts

@@ -36,14 +36,14 @@ export declare type Filter<E = Q_EnumValue<"user" | string>> = MakeFilter<AttrFi
 export declare type Projection = {
     "#id"?: NodeId;
     [k: string]: any;
-    id: 1;
-    $$createAt$$?: 1;
-    $$updateAt$$?: 1;
-    $$seq$$?: 1;
-    modiId?: 1;
+    id: number;
+    $$createAt$$?: number;
+    $$updateAt$$?: number;
+    $$seq$$?: number;
+    modiId?: number;
     modi?: Modi.Projection;
-    entity?: 1;
-    entityId?: 1;
+    entity?: number;
+    entityId?: number;
     user?: User.Projection;
 } & Partial<ExprOp<OpAttr | string>>;
 export declare type ExportProjection = {
@@ -60,30 +60,30 @@ export declare type ExportProjection = {
     user?: User.ExportProjection;
 } & Partial<ExprOp<OpAttr | string>>;
 declare type ModiEntityIdProjection = OneOf<{
-    id: 1;
+    id: number;
 }>;
 declare type ModiIdProjection = OneOf<{
-    modiId: 1;
+    modiId: number;
 }>;
 declare type UserIdProjection = OneOf<{
-    entityId: 1;
+    entityId: number;
 }>;
 export declare type SortAttr = {
-    id: 1;
+    id: number;
 } | {
-    $$createAt$$: 1;
+    $$createAt$$: number;
 } | {
-    $$seq$$: 1;
+    $$seq$$: number;
 } | {
-    $$updateAt$$: 1;
+    $$updateAt$$: number;
 } | {
-    modiId: 1;
+    modiId: number;
 } | {
     modi: Modi.SortAttr;
 } | {
-    entity: 1;
+    entity: number;
 } | {
-    entityId: 1;
+    entityId: number;
 } | {
     user: User.SortAttr;
 } | {

package/lib/base-app-domain/Oper/Schema.d.ts

@@ -41,15 +41,15 @@ export declare type Filter = MakeFilter<AttrFilter & ExprOp<OpAttr | string>>;
 export declare type Projection = {
     "#id"?: NodeId;
     [k: string]: any;
-    id: 1;
-    $$createAt$$?: 1;
-    $$updateAt$$?: 1;
-    $$seq$$?: 1;
-    action?: 1;
-    data?: 1;
-    filter?: 1;
-    extra?: 1;
-    operatorId?: 1;
+    id: number;
+    $$createAt$$?: number;
+    $$updateAt$$?: number;
+    $$seq$$?: number;
+    action?: number;
+    data?: number;
+    filter?: number;
+    extra?: number;
+    operatorId?: number;
     operator?: User.Projection;
     operEntity$oper?: OperEntity.Selection & {
         $entity: "operEntity";
@@ -73,23 +73,23 @@ export declare type ExportProjection = {
     };
 } & Partial<ExprOp<OpAttr | string>>;
 declare type OperIdProjection = OneOf<{
-    id: 1;
+    id: number;
 }>;
 declare type UserIdProjection = OneOf<{
-    operatorId: 1;
+    operatorId: number;
 }>;
 export declare type SortAttr = {
-    id: 1;
+    id: number;
 } | {
-    $$createAt$$: 1;
+    $$createAt$$: number;
 } | {
-    $$seq$$: 1;
+    $$seq$$: number;
 } | {
-    $$updateAt$$: 1;
+    $$updateAt$$: number;
 } | {
-    action: 1;
+    action: number;
 } | {
-    operatorId: 1;
+    operatorId: number;
 } | {
     operator: User.SortAttr;
 } | {

package/lib/base-app-domain/OperEntity/Schema.d.ts

@@ -39,14 +39,14 @@ export declare type Filter<E = Q_EnumValue<"modi" | "user" | string>> = MakeFilt
 export declare type Projection = {
     "#id"?: NodeId;
     [k: string]: any;
-    id: 1;
-    $$createAt$$?: 1;
-    $$updateAt$$?: 1;
-    $$seq$$?: 1;
-    operId?: 1;
+    id: number;
+    $$createAt$$?: number;
+    $$updateAt$$?: number;
+    $$seq$$?: number;
+    operId?: number;
     oper?: Oper.Projection;
-    entity?: 1;
-    entityId?: 1;
+    entity?: number;
+    entityId?: number;
     modi?: Modi.Projection;
     user?: User.Projection;
 } & Partial<ExprOp<OpAttr | string>>;
@@ -65,33 +65,33 @@ export declare type ExportProjection = {
     user?: User.ExportProjection;
 } & Partial<ExprOp<OpAttr | string>>;
 declare type OperEntityIdProjection = OneOf<{
-    id: 1;
+    id: number;
 }>;
 declare type OperIdProjection = OneOf<{
-    operId: 1;
+    operId: number;
 }>;
 declare type ModiIdProjection = OneOf<{
-    entityId: 1;
+    entityId: number;
 }>;
 declare type UserIdProjection = OneOf<{
-    entityId: 1;
+    entityId: number;
 }>;
 export declare type SortAttr = {
-    id: 1;
+    id: number;
 } | {
-    $$createAt$$: 1;
+    $$createAt$$: number;
 } | {
-    $$seq$$: 1;
+    $$seq$$: number;
 } | {
-    $$updateAt$$: 1;
+    $$updateAt$$: number;
 } | {
-    operId: 1;
+    operId: number;
 } | {
     oper: Oper.SortAttr;
 } | {
-    entity: 1;
+    entity: number;
 } | {
-    entityId: 1;
+    entityId: number;
 } | {
     modi: Modi.SortAttr;
 } | {

package/lib/base-app-domain/User/Schema.d.ts

@@ -36,13 +36,13 @@ export declare type Filter = MakeFilter<AttrFilter & ExprOp<OpAttr | string>>;
 export declare type Projection = {
     "#id"?: NodeId;
     [k: string]: any;
-    id: 1;
-    $$createAt$$?: 1;
-    $$updateAt$$?: 1;
-    $$seq$$?: 1;
-    name?: 1;
-    nickname?: 1;
-    password?: 1;
+    id: number;
+    $$createAt$$?: number;
+    $$updateAt$$?: number;
+    $$seq$$?: number;
+    name?: number;
+    nickname?: number;
+    password?: number;
     oper$operator?: Oper.Selection & {
         $entity: "oper";
     };
@@ -74,22 +74,22 @@ export declare type ExportProjection = {
     };
 } & Partial<ExprOp<OpAttr | string>>;
 declare type UserIdProjection = OneOf<{
-    id: 1;
+    id: number;
 }>;
 export declare type SortAttr = {
-    id: 1;
+    id: number;
 } | {
-    $$createAt$$: 1;
+    $$createAt$$: number;
 } | {
-    $$seq$$: 1;
+    $$seq$$: number;
 } | {
-    $$updateAt$$: 1;
+    $$updateAt$$: number;
 } | {
-    name: 1;
+    name: number;
 } | {
-    nickname: 1;
+    nickname: number;
 } | {
-    password: 1;
+    password: number;
 } | {
     [k: string]: any;
 } | OneOf<ExprOp<OpAttr | string>>;

package/lib/checkers/index.d.ts

@@ -1,3 +1,5 @@
 import { EntityDict } from '../base-app-domain';
-import { StorageSchema, EntityDict as BaseEntityDict, Context } from '../types';
-export declare function createDynamicCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends Context<ED>>(schema: StorageSchema<ED>): import("../types").Checker<ED, keyof ED, Cxt>[];
+import { AsyncContext } from '../store/AsyncRowStore';
+import { SyncContext } from '../store/SyncRowStore';
+import { StorageSchema, EntityDict as BaseEntityDict } from '../types';
+export declare function createDynamicCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): import("../types").RowChecker<ED, keyof ED, Cxt>[];

package/lib/compiler/schemalBuilder.js

@@ -1336,7 +1336,7 @@ function constructProjection(statements, entity) {
     statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Projection"), undefined, factory.createIntersectionTypeNode([
         factory.createTypeLiteralNode(MetaPropertySignaturs.concat(properties.map(function (_a) {
             var _b = tslib_1.__read(_a, 3), n = _b[0], q = _b[1], v = _b[2];
-            return factory.createPropertySignature(undefined, n, q ? undefined : factory.createToken(ts.SyntaxKind.QuestionToken), v || factory.createLiteralTypeNode(factory.createNumericLiteral("1")));
+            return factory.createPropertySignature(undefined, n, q ? undefined : factory.createToken(ts.SyntaxKind.QuestionToken), v || factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword));
         }))),
         exprNode,
     ])));
@@ -1352,7 +1352,7 @@ function constructProjection(statements, entity) {
     for (var foreignKey in foreignKeyProperties) {
         var identifier = "".concat(foreignKey, "IdProjection");
         statements.push(factory.createTypeAliasDeclaration(undefined, undefined, factory.createIdentifier(identifier), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OneOf"), [
-            factory.createTypeLiteralNode(foreignKeyProperties[foreignKey].map(function (attr) { return factory.createPropertySignature(undefined, attr ? factory.createIdentifier("".concat(attr, "Id")) : 'id', undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1"))); }))
+            factory.createTypeLiteralNode(foreignKeyProperties[foreignKey].map(function (attr) { return factory.createPropertySignature(undefined, attr ? factory.createIdentifier("".concat(attr, "Id")) : 'id', undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)); }))
         ])));
     }
 }
@@ -1493,13 +1493,13 @@ function constructSorter(statements, entity) {
     var schemaAttrs = Schema[entity].schemaAttrs;
     var members = [
         // id: 1
-        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("id"), undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]),
+        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("id"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]),
         // $$createAt$$: 1
-        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$createAt$$"), undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]),
+        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$createAt$$"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]),
         // $$seq$$: 1
-        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$seq$$"), undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]),
+        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$seq$$"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]),
         // $$updateAt$$: 1
-        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$updateAt$$"), undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]),
+        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$updateAt$$"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]),
     ];
     var _b = ManyToOne, _c = entity, manyToOneSet = _b[_c];
     var _loop_6 = function (attr) {
@@ -1519,7 +1519,7 @@ function constructSorter(statements, entity) {
                     case 'Datetime':
                     case 'Image':
                     case 'File': {
-                        type2 = factory.createLiteralTypeNode(factory.createNumericLiteral("1"));
+                        type2 = factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
                         break;
                     }
                     default: {
@@ -1530,11 +1530,11 @@ function constructSorter(statements, entity) {
                         });
                         if (manyToOneItem) {
                             type2 = factory.createTypeReferenceNode(createForeignRef(entity, text2_5, 'SortAttr'));
-                            members.push(factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("".concat(name_5.text, "Id")), undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]));
+                            members.push(factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("".concat(name_5.text, "Id")), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]));
                         }
                         else if (!['Object'].includes(text)) {
                             // todo 对State的专门处理
-                            type2 = factory.createLiteralTypeNode(factory.createNumericLiteral("1"));
+                            type2 = factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
                         }
                     }
                 }
@@ -1544,7 +1544,7 @@ function constructSorter(statements, entity) {
             }
         }
         else if (ts.isUnionTypeNode(type) && ts.isLiteralTypeNode(type.types[0]) || ts.isLiteralTypeNode(type)) {
-            members.push(factory.createTypeLiteralNode([factory.createPropertySignature(undefined, name_5, undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]));
+            members.push(factory.createTypeLiteralNode([factory.createPropertySignature(undefined, name_5, undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]));
         }
         else {
             // 本地规定的shape，非结构化属性不参与排序

package/lib/store/AsyncRowStore.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord } from "../types";
+import { IncomingHttpHeaders } from "http";
+export declare abstract class AsyncContext<ED extends EntityDict> implements Context {
+    private rowStore;
+    private uuid?;
+    opRecords: OpRecord<ED>[];
+    private scene?;
+    private headers?;
+    events: {
+        commit: Array<() => Promise<void>>;
+        rollback: Array<() => Promise<void>>;
+    };
+    constructor(store: AsyncRowStore<ED, AsyncContext<ED>>, headers?: IncomingHttpHeaders);
+    setHeaders(headers: IncomingHttpHeaders): void;
+    getHeader(key: string): string | string[] | undefined;
+    getScene(): string | undefined;
+    setScene(scene?: string): void;
+    private resetEvents;
+    on(event: 'commit' | 'rollback', callback: () => Promise<void>): void;
+    /**
+     * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
+     * @param options
+     */
+    begin(options?: TxnOption): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    operate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], option: OP): Promise<OperationResult<ED>>;
+    select<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], option: OP): Promise<Partial<ED[T]["Schema"]>[]>;
+    count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, option: OP): Promise<number>;
+    mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;
+    getCurrentTxnId(): string | undefined;
+    getSchema(): import("../types").StorageSchema<ED>;
+    abstract isRoot(): boolean;
+    abstract getCurrentUserId(allowUnloggedIn?: boolean): string | undefined;
+    abstract toString(): string;
+}
+export interface AsyncRowStore<ED extends EntityDict, Cxt extends Context> extends RowStore<ED> {
+    operate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): Promise<OperationResult<ED>>;
+    select<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
+    count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): Promise<number>;
+    begin(option?: TxnOption): Promise<string>;
+    commit(txnId: string): Promise<void>;
+    rollback(txnId: string): Promise<void>;
+}

package/lib/store/{UniversalContext.js → AsyncRowStore.js}

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniversalContext = void 0;
+exports.AsyncContext = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
-var concurrent_1 = require("../utils/concurrent");
-var UniversalContext = /** @class */ (function () {
-    function UniversalContext(store, headers) {
+var AsyncContext = /** @class */ (function () {
+    function AsyncContext(store, headers) {
         this.rowStore = store;
         this.opRecords = [];
-        this.rwLock = new concurrent_1.RWLock();
         this.events = {
             commit: [],
             rollback: [],
@@ -17,56 +15,54 @@ var UniversalContext = /** @class */ (function () {
             this.headers = headers;
         }
     }
-    UniversalContext.prototype.setHeaders = function (headers) {
+    AsyncContext.prototype.setHeaders = function (headers) {
         this.headers = headers;
     };
-    UniversalContext.prototype.getHeader = function (key) {
+    AsyncContext.prototype.getHeader = function (key) {
         if (this.headers) {
             return this.headers[key];
         }
     };
-    UniversalContext.prototype.getScene = function () {
+    AsyncContext.prototype.getScene = function () {
         return this.scene;
     };
-    UniversalContext.prototype.setScene = function (scene) {
+    AsyncContext.prototype.setScene = function (scene) {
         this.scene = scene;
     };
-    UniversalContext.prototype.resetEvents = function () {
+    AsyncContext.prototype.resetEvents = function () {
         this.events = {
             commit: [],
             rollback: [],
         };
     };
-    UniversalContext.prototype.on = function (event, callback) {
+    AsyncContext.prototype.on = function (event, callback) {
         this.uuid && this.events[event].push(callback);
     };
     /**
      * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
      * @param options
      */
-    UniversalContext.prototype.begin = function (options) {
+    AsyncContext.prototype.begin = function (options) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _a;
             return tslib_1.__generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.rwLock.acquire('X')];
-                    case 1:
-                        _b.sent();
-                        if (!!this.uuid) return [3 /*break*/, 3];
+                    case 0:
+                        if (!!this.uuid) return [3 /*break*/, 2];
                         _a = this;
                         return [4 /*yield*/, this.rowStore.begin(options)];
-                    case 2:
+                    case 1:
                         _a.uuid = _b.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
+                        return [3 /*break*/, 3];
+                    case 2:
                         (0, assert_1.default)(false);
-                        _b.label = 4;
-                    case 4: return [2 /*return*/];
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
-    UniversalContext.prototype.commit = function () {
+    AsyncContext.prototype.commit = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _a, _b, e, e_1_1;
             var e_1, _c;
@@ -77,9 +73,7 @@ var UniversalContext = /** @class */ (function () {
                         return [4 /*yield*/, this.rowStore.commit(this.uuid)];
                     case 1:
                         _d.sent();
-                        // console.log('commit', this.uuid);
                         this.uuid = undefined;
-                        this.rwLock.release();
                         _d.label = 2;
                     case 2:
                         _d.trys.push([2, 7, 8, 9]);
@@ -114,7 +108,7 @@ var UniversalContext = /** @class */ (function () {
             });
         });
     };
-    UniversalContext.prototype.rollback = function () {
+    AsyncContext.prototype.rollback = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _a, _b, e, e_2_1;
             var e_2, _c;
@@ -127,7 +121,6 @@ var UniversalContext = /** @class */ (function () {
                         _d.sent();
                         // console.log('rollback', this.uuid);
                         this.uuid = undefined;
-                        this.rwLock.release();
                         _d.label = 2;
                     case 2:
                         _d.trys.push([2, 7, 8, 9]);
@@ -162,9 +155,26 @@ var UniversalContext = /** @class */ (function () {
             });
         });
     };
-    UniversalContext.prototype.getCurrentTxnId = function () {
+    AsyncContext.prototype.operate = function (entity, operation, option) {
+        return this.rowStore.operate(entity, operation, this, option);
+    };
+    AsyncContext.prototype.select = function (entity, selection, option) {
+        return this.rowStore.select(entity, selection, this, option);
+    };
+    AsyncContext.prototype.count = function (entity, selection, option) {
+        return this.rowStore.count(entity, selection, this, option);
+    };
+    AsyncContext.prototype.mergeMultipleResults = function (toBeMerged) {
+        return this.rowStore.mergeMultipleResults(toBeMerged);
+    };
+    AsyncContext.prototype.getCurrentTxnId = function () {
         return this.uuid;
     };
-    return UniversalContext;
+    AsyncContext.prototype.getSchema = function () {
+        return this.rowStore.getSchema();
+    };
+    return AsyncContext;
 }());
-exports.UniversalContext = UniversalContext;
+exports.AsyncContext = AsyncContext;
+;
+;