oak-domain 4.1.0 → 4.2.0

package/lib/entities/Oper.d.ts

@@ -1,4 +1,4 @@
-import { String } from '../types/DataType';
+import { String, Datetime } from '../types/DataType';
 import { EntityShape } from '../types/Entity';
 import { Schema as User } from './User';
 export interface Schema extends EntityShape {
@@ -8,4 +8,5 @@ export interface Schema extends EntityShape {
     extra?: Object;
     operator?: User;
     targetEntity: String<32>;
+    bornAt: Datetime;
 }

package/lib/entities/Oper.js

@@ -12,10 +12,25 @@ const entityDesc = {
                 extra: '其它',
                 operator: '操作者',
                 targetEntity: '关联对象',
+                bornAt: '诞生时间'
             },
         },
     },
     configuration: {
         actionType: 'appendOnly',
-    }
+    },
+    indexes: [
+        {
+            name: 'index_bornAt_operatorId',
+            attributes: [
+                {
+                    name: 'bornAt',
+                    direction: 'DESC',
+                },
+                {
+                    name: 'operator',
+                },
+            ]
+        }
+    ]
 };

package/lib/entities/User.d.ts

@@ -1,8 +1,18 @@
 import { String, Text } from '../types/DataType';
 import { EntityShape } from '../types/Entity';
+import { ActionDef } from '../types/Action';
+import { EntityDesc } from '../types/EntityDesc';
 export interface Schema extends EntityShape {
     name?: String<16>;
     nickname?: String<64>;
     password?: Text;
     ref?: Schema;
 }
+type UserAction = 'mergeTo';
+type UserState = 'normal' | 'merged';
+export type Action = UserAction;
+export declare const UserActionDef: ActionDef<UserAction, UserState>;
+export declare const entityDesc: EntityDesc<Schema, Action, '', {
+    userState: UserState;
+}>;
+export {};

package/lib/entities/User.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityDesc = exports.UserActionDef = void 0;
 ;
-const UserActionDef = {
+exports.UserActionDef = {
     stm: {
         mergeTo: ['normal', 'merged'],
     },
 };
-const entityDesc = {
+exports.entityDesc = {
     locales: {
         zh_CN: {
             name: '用户',

package/lib/index.d.ts

@@ -1,23 +1 @@
-export { storageSchema } from './base-app-domain';
 export type { EntityDict as BaseEntityDict } from './base-app-domain';
-export * from './store/AsyncRowStore';
-export * from './store/SyncRowStore';
-export * from './store/CascadeStore';
-export * from './store/relation';
-export * from './store/RelationAuth';
-export * from './store/TriggerExecutor';
-export * from './store/actionDef';
-export * from './store/checker';
-export * from './store/filter';
-export * from './store/modi';
-export * from './timers/oper';
-export * from './timers/vaccum';
-export * from './actions/action';
-export * from './actions/relation';
-export { SimpleConnector } from './utils/SimpleConnector';
-export { assert } from './utils/assert';
-export { composeUrl } from './utils/domain';
-export { checkAttributesNotNull, checkAttributesScope, } from './utils/validator';
-export { compareVersion } from './utils/version';
-export * from './types';
-export { generateNewIdAsync, generateNewId, shrinkUuidTo32Bytes, expandUuidTo36Bytes, } from './utils/uuid';

package/lib/index.js

@@ -1,37 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expandUuidTo36Bytes = exports.shrinkUuidTo32Bytes = exports.generateNewId = exports.generateNewIdAsync = exports.compareVersion = exports.checkAttributesScope = exports.checkAttributesNotNull = exports.composeUrl = exports.assert = exports.SimpleConnector = exports.storageSchema = void 0;
-const tslib_1 = require("tslib");
-var base_app_domain_1 = require("./base-app-domain");
-Object.defineProperty(exports, "storageSchema", { enumerable: true, get: function () { return base_app_domain_1.storageSchema; } });
-tslib_1.__exportStar(require("./store/AsyncRowStore"), exports);
-tslib_1.__exportStar(require("./store/SyncRowStore"), exports);
-tslib_1.__exportStar(require("./store/CascadeStore"), exports);
-tslib_1.__exportStar(require("./store/relation"), exports);
-tslib_1.__exportStar(require("./store/RelationAuth"), exports);
-tslib_1.__exportStar(require("./store/TriggerExecutor"), exports);
-tslib_1.__exportStar(require("./store/actionDef"), exports);
-tslib_1.__exportStar(require("./store/checker"), exports);
-tslib_1.__exportStar(require("./store/filter"), exports);
-tslib_1.__exportStar(require("./store/modi"), exports);
-tslib_1.__exportStar(require("./timers/oper"), exports);
-tslib_1.__exportStar(require("./timers/vaccum"), exports);
-tslib_1.__exportStar(require("./actions/action"), exports);
-tslib_1.__exportStar(require("./actions/relation"), exports);
-var SimpleConnector_1 = require("./utils/SimpleConnector");
-Object.defineProperty(exports, "SimpleConnector", { enumerable: true, get: function () { return SimpleConnector_1.SimpleConnector; } });
-var assert_1 = require("./utils/assert");
-Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return assert_1.assert; } });
-var domain_1 = require("./utils/domain");
-Object.defineProperty(exports, "composeUrl", { enumerable: true, get: function () { return domain_1.composeUrl; } });
-var validator_1 = require("./utils/validator");
-Object.defineProperty(exports, "checkAttributesNotNull", { enumerable: true, get: function () { return validator_1.checkAttributesNotNull; } });
-Object.defineProperty(exports, "checkAttributesScope", { enumerable: true, get: function () { return validator_1.checkAttributesScope; } });
-var version_1 = require("./utils/version");
-Object.defineProperty(exports, "compareVersion", { enumerable: true, get: function () { return version_1.compareVersion; } });
-tslib_1.__exportStar(require("./types"), exports);
-var uuid_1 = require("./utils/uuid");
-Object.defineProperty(exports, "generateNewIdAsync", { enumerable: true, get: function () { return uuid_1.generateNewIdAsync; } });
-Object.defineProperty(exports, "generateNewId", { enumerable: true, get: function () { return uuid_1.generateNewId; } });
-Object.defineProperty(exports, "shrinkUuidTo32Bytes", { enumerable: true, get: function () { return uuid_1.shrinkUuidTo32Bytes; } });
-Object.defineProperty(exports, "expandUuidTo36Bytes", { enumerable: true, get: function () { return uuid_1.expandUuidTo36Bytes; } });
+// export * from './types';

package/lib/store/AsyncRowStore.d.ts

@@ -1,65 +1,66 @@
-/// <reference types="node" />
-import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord, AggregationResult, ClusterInfo } from "../types";
-import { IncomingHttpHeaders } from "http";
-/**
- * 服务器端执行的异步环境的底层抽象
- */
-export declare abstract class AsyncContext<ED extends EntityDict> implements Context {
-    rowStore: AsyncRowStore<ED, this>;
-    private uuid?;
-    opRecords: OpRecord<ED>[];
-    private scene?;
-    headers?: IncomingHttpHeaders;
-    clusterInfo?: ClusterInfo;
-    opResult: OperationResult<ED>;
-    private message?;
-    events: {
-        commit: Array<() => Promise<void>>;
-        rollback: Array<() => Promise<void>>;
-    };
-    /**
-     * 在返回结果前调用，对数据行进行一些预处理，比如将一些敏感的列隐藏
-     */
-    abstract refineOpRecords(): Promise<void>;
-    constructor(store: AsyncRowStore<ED, AsyncContext<ED>>);
-    restartToExecute(routine: (context: this) => Promise<any>): Promise<void>;
-    getHeader(key: string): string | string[] | undefined;
-    getScene(): string | undefined;
-    setScene(scene?: string): void;
-    private resetEvents;
-    on(event: 'commit' | 'rollback', callback: () => Promise<void>): void;
-    saveOpRecord<T extends keyof ED>(entity: T, operation: ED[T]['Operation']): 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"]>[]>;
-    aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], option: OP): Promise<AggregationResult<ED[T]["Schema"]>>;
-    count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, option: OP): Promise<number>;
-    exec(script: string, txnId?: string): Promise<void>;
-    mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;
-    getCurrentTxnId(): string | undefined;
-    getSchema(): import("../types").StorageSchema<ED>;
-    setMessage(message: string): void;
-    getMessage(): string | undefined;
-    abstract isRoot(): boolean;
-    abstract getCurrentUserId(allowUnloggedIn?: boolean): string | undefined;
-    abstract toString(): Promise<string>;
-    abstract initialize(data: any): Promise<void>;
-    abstract allowUserUpdate(): boolean;
-    abstract openRootMode(): () => void;
-}
-export interface AsyncRowStore<ED extends EntityDict, Cxt extends AsyncContext<ED>> 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']>[]>;
-    aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<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>;
-    exec(script: string, txnId?: string): Promise<void>;
-}
+/// <reference types="node" />
+import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord, AggregationResult, ClusterInfo } from "../types";
+import { IncomingHttpHeaders } from "http";
+/**
+ * 服务器端执行的异步环境的底层抽象
+ */
+export declare abstract class AsyncContext<ED extends EntityDict> implements Context {
+    rowStore: AsyncRowStore<ED, this>;
+    private uuid?;
+    opRecords: OpRecord<ED>[];
+    private scene?;
+    headers?: IncomingHttpHeaders;
+    clusterInfo?: ClusterInfo;
+    opResult: OperationResult<ED>;
+    private message?;
+    events: {
+        commit: Array<() => Promise<void>>;
+        rollback: Array<() => Promise<void>>;
+    };
+    /**
+     * 在返回结果前调用，对数据行进行一些预处理，比如将一些敏感的列隐藏
+     */
+    abstract refineOpRecords(): Promise<void>;
+    constructor(store: AsyncRowStore<ED, AsyncContext<ED>>);
+    restartToExecute(routine: (context: this) => Promise<any>): Promise<void>;
+    getHeader(key: string): string | string[] | undefined;
+    getScene(): string | undefined;
+    setScene(scene?: string): void;
+    private resetEvents;
+    on(event: 'commit' | 'rollback', callback: () => Promise<void>): void;
+    saveOpRecord<T extends keyof ED>(entity: T, operation: ED[T]['Operation']): 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"]>[]>;
+    aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], option: OP): Promise<AggregationResult<ED[T]["Schema"]>>;
+    count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, option: OP): Promise<number>;
+    exec(script: string, txnId?: string): Promise<void>;
+    mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;
+    getCurrentTxnId(): string | undefined;
+    getSchema(): import("../types").StorageSchema<ED>;
+    setMessage(message: string): void;
+    getMessage(): string | undefined;
+    abstract isRoot(): boolean;
+    abstract getCurrentUserId(allowUnloggedIn?: boolean): string | undefined;
+    abstract setCurrentUserId(userId: string | undefined): void;
+    abstract toString(): Promise<string>;
+    abstract initialize(data: any): Promise<void>;
+    abstract allowUserUpdate(): boolean;
+    abstract openRootMode(): () => void;
+}
+export interface AsyncRowStore<ED extends EntityDict, Cxt extends AsyncContext<ED>> 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']>[]>;
+    aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<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>;
+    exec(script: string, txnId?: string): Promise<void>;
+}

package/lib/store/AsyncRowStore.js

@@ -1,180 +1,180 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncContext = void 0;
-const tslib_1 = require("tslib");
-const action_1 = require("../actions/action");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-/**
- * 服务器端执行的异步环境的底层抽象
- */
-class AsyncContext {
-    rowStore;
-    uuid;
-    opRecords;
-    scene;
-    headers;
-    clusterInfo;
-    opResult;
-    message;
-    events;
-    constructor(store) {
-        this.rowStore = store;
-        this.opRecords = [];
-        this.events = {
-            commit: [],
-            rollback: [],
-        };
-        this.opResult = {};
-    }
-    // 使一个上下文重新开始事务执行，清除历史数据（定时器中使用）
-    async restartToExecute(routine) {
-        const newContext = !this.uuid ? this : {
-            ...this,
-        }; // 这里可能有问题，继承的context对象中如果有对象属性会变成指针公用，但是估计目前是跑不到的。by Xc 20231215
-        if (newContext !== this) {
-            console.warn('restartToExecute跑出了非重用当前context的情况，请仔细调试');
-        }
-        newContext.opRecords = [];
-        newContext.events = {
-            commit: [],
-            rollback: [],
-        };
-        newContext.opResult = {};
-        await newContext.begin();
-        try {
-            await routine(newContext);
-            await newContext.commit();
-        }
-        catch (err) {
-            await newContext.rollback();
-            throw err;
-        }
-    }
-    getHeader(key) {
-        if (this.headers) {
-            return this.headers[key];
-        }
-    }
-    getScene() {
-        return this.scene;
-    }
-    setScene(scene) {
-        this.scene = scene;
-    }
-    resetEvents() {
-        this.events = {
-            commit: [],
-            rollback: [],
-        };
-    }
-    on(event, callback) {
-        this.uuid && this.events[event].push(callback);
-    }
-    saveOpRecord(entity, operation) {
-        const { action, data, filter, id } = operation;
-        switch (action) {
-            case 'create': {
-                this.opRecords.push({
-                    id,
-                    a: 'c',
-                    e: entity,
-                    d: data
-                });
-                break;
-            }
-            case 'remove': {
-                this.opRecords.push({
-                    id,
-                    a: 'r',
-                    e: entity,
-                    f: filter,
-                });
-                break;
-            }
-            default: {
-                (0, assert_1.default)(!action_1.readOnlyActions.includes(action));
-                this.opRecords.push({
-                    id,
-                    a: 'u',
-                    e: entity,
-                    d: data,
-                    f: filter,
-                });
-            }
-        }
-    }
-    /**
-     * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
-     * @param options
-     */
-    async begin(options) {
-        if (!this.uuid) {
-            this.uuid = await this.rowStore.begin(options);
-        }
-        else {
-            (0, assert_1.default)(false);
-        }
-    }
-    async commit() {
-        if (this.uuid) {
-            await this.rowStore.commit(this.uuid);
-            const { commit: commitEvents } = this.events;
-            for (const e of commitEvents) {
-                await e();
-            }
-            this.uuid = undefined;
-            this.resetEvents();
-            this.opRecords = [];
-            this.opResult = {};
-            this.message = '';
-        }
-    }
-    async rollback() {
-        if (this.uuid) {
-            await this.rowStore.rollback(this.uuid);
-            const { rollback: rollbackEvents } = this.events;
-            for (const e of rollbackEvents) {
-                await e();
-            }
-            this.uuid = undefined;
-            this.opRecords = [];
-            this.opResult = {};
-            this.resetEvents();
-        }
-    }
-    async operate(entity, operation, option) {
-        const result = await this.rowStore.operate(entity, operation, this, option);
-        this.opResult = this.mergeMultipleResults([this.opResult, result]);
-        return result;
-    }
-    select(entity, selection, option) {
-        return this.rowStore.select(entity, selection, this, option);
-    }
-    aggregate(entity, aggregation, option) {
-        return this.rowStore.aggregate(entity, aggregation, this, option);
-    }
-    count(entity, selection, option) {
-        return this.rowStore.count(entity, selection, this, option);
-    }
-    exec(script, txnId) {
-        return this.rowStore.exec(script, txnId);
-    }
-    mergeMultipleResults(toBeMerged) {
-        return this.rowStore.mergeMultipleResults(toBeMerged);
-    }
-    getCurrentTxnId() {
-        return this.uuid;
-    }
-    getSchema() {
-        return this.rowStore.getSchema();
-    }
-    setMessage(message) {
-        this.message = message;
-    }
-    getMessage() {
-        return this.message;
-    }
-}
-exports.AsyncContext = AsyncContext;
-;
-;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncContext = void 0;
+const tslib_1 = require("tslib");
+const action_1 = require("../actions/action");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+/**
+ * 服务器端执行的异步环境的底层抽象
+ */
+class AsyncContext {
+    rowStore;
+    uuid;
+    opRecords;
+    scene;
+    headers;
+    clusterInfo;
+    opResult;
+    message;
+    events;
+    constructor(store) {
+        this.rowStore = store;
+        this.opRecords = [];
+        this.events = {
+            commit: [],
+            rollback: [],
+        };
+        this.opResult = {};
+    }
+    // 使一个上下文重新开始事务执行，清除历史数据（定时器中使用）
+    async restartToExecute(routine) {
+        const newContext = !this.uuid ? this : {
+            ...this,
+        }; // 这里可能有问题，继承的context对象中如果有对象属性会变成指针公用，但是估计目前是跑不到的。by Xc 20231215
+        if (newContext !== this) {
+            console.warn('restartToExecute跑出了非重用当前context的情况，请仔细调试');
+        }
+        newContext.opRecords = [];
+        newContext.events = {
+            commit: [],
+            rollback: [],
+        };
+        newContext.opResult = {};
+        await newContext.begin();
+        try {
+            await routine(newContext);
+            await newContext.commit();
+        }
+        catch (err) {
+            await newContext.rollback();
+            throw err;
+        }
+    }
+    getHeader(key) {
+        if (this.headers) {
+            return this.headers[key];
+        }
+    }
+    getScene() {
+        return this.scene;
+    }
+    setScene(scene) {
+        this.scene = scene;
+    }
+    resetEvents() {
+        this.events = {
+            commit: [],
+            rollback: [],
+        };
+    }
+    on(event, callback) {
+        this.uuid && this.events[event].push(callback);
+    }
+    saveOpRecord(entity, operation) {
+        const { action, data, filter, id } = operation;
+        switch (action) {
+            case 'create': {
+                this.opRecords.push({
+                    id,
+                    a: 'c',
+                    e: entity,
+                    d: data
+                });
+                break;
+            }
+            case 'remove': {
+                this.opRecords.push({
+                    id,
+                    a: 'r',
+                    e: entity,
+                    f: filter,
+                });
+                break;
+            }
+            default: {
+                (0, assert_1.default)(!action_1.readOnlyActions.includes(action));
+                this.opRecords.push({
+                    id,
+                    a: 'u',
+                    e: entity,
+                    d: data,
+                    f: filter,
+                });
+            }
+        }
+    }
+    /**
+     * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
+     * @param options
+     */
+    async begin(options) {
+        if (!this.uuid) {
+            this.uuid = await this.rowStore.begin(options);
+        }
+        else {
+            (0, assert_1.default)(false);
+        }
+    }
+    async commit() {
+        if (this.uuid) {
+            await this.rowStore.commit(this.uuid);
+            const { commit: commitEvents } = this.events;
+            for (const e of commitEvents) {
+                await e();
+            }
+            this.uuid = undefined;
+            this.resetEvents();
+            this.opRecords = [];
+            this.opResult = {};
+            this.message = '';
+        }
+    }
+    async rollback() {
+        if (this.uuid) {
+            await this.rowStore.rollback(this.uuid);
+            const { rollback: rollbackEvents } = this.events;
+            for (const e of rollbackEvents) {
+                await e();
+            }
+            this.uuid = undefined;
+            this.opRecords = [];
+            this.opResult = {};
+            this.resetEvents();
+        }
+    }
+    async operate(entity, operation, option) {
+        const result = await this.rowStore.operate(entity, operation, this, option);
+        this.opResult = this.mergeMultipleResults([this.opResult, result]);
+        return result;
+    }
+    select(entity, selection, option) {
+        return this.rowStore.select(entity, selection, this, option);
+    }
+    aggregate(entity, aggregation, option) {
+        return this.rowStore.aggregate(entity, aggregation, this, option);
+    }
+    count(entity, selection, option) {
+        return this.rowStore.count(entity, selection, this, option);
+    }
+    exec(script, txnId) {
+        return this.rowStore.exec(script, txnId);
+    }
+    mergeMultipleResults(toBeMerged) {
+        return this.rowStore.mergeMultipleResults(toBeMerged);
+    }
+    getCurrentTxnId() {
+        return this.uuid;
+    }
+    getSchema() {
+        return this.rowStore.getSchema();
+    }
+    setMessage(message) {
+        this.message = message;
+    }
+    getMessage() {
+        return this.message;
+    }
+}
+exports.AsyncContext = AsyncContext;
+;
+;