oak-domain 4.0.1 → 4.0.3

package/lib/types/Geo.d.ts

@@ -1,18 +1,18 @@
-export type Point = [number, number];
-export type Path = Array<Point>;
-export type Polygon = Array<Path>;
-export type Circle = [Point, number];
-export type SingleGeo = {
-    type: 'point';
-    coordinate: Point;
-} | {
-    type: 'path';
-    coordinate: Path;
-} | {
-    type: 'polygon';
-    coordinate: Polygon;
-} | {
-    type: 'circle';
-    coordinate: Circle;
-};
-export type Geo = SingleGeo | SingleGeo[];
+export type Point = [number, number];
+export type Path = Array<Point>;
+export type Polygon = Array<Path>;
+export type Circle = [Point, number];
+export type SingleGeo = {
+    type: 'point';
+    coordinate: Point;
+} | {
+    type: 'path';
+    coordinate: Path;
+} | {
+    type: 'polygon';
+    coordinate: Polygon;
+} | {
+    type: 'circle';
+    coordinate: Circle;
+};
+export type Geo = SingleGeo | SingleGeo[];

package/lib/types/Locale.d.ts

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

package/lib/types/Logger.d.ts

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

package/lib/types/Polyfill.d.ts

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

package/lib/types/Port.d.ts

@@ -1,18 +1,18 @@
-import { AsyncContext } from "../store/AsyncRowStore";
-import { EntityDict } from "./Entity";
-export type Exportation<ED extends EntityDict, T extends keyof ED, K extends string, Cxt extends AsyncContext<ED>> = {
-    name: string;
-    id: string;
-    entity: T;
-    projection: ED[T]['Selection']['data'];
-    headers?: K[];
-    makeHeaders?: (dataList: Partial<ED[T]['Schema']>[]) => string[];
-    fn: (data: ED[T]['Schema'], context?: Cxt, properties?: Record<string, any>) => Promise<Partial<Record<string, string | number | boolean | null>>> | Partial<Record<string, string | number | boolean | null>>;
-};
-export type Importation<ED extends EntityDict, T extends keyof ED, K extends string, Cxt extends AsyncContext<ED>> = {
-    name: string;
-    id: string;
-    entity: T;
-    headers: K[];
-    fn: (data: Partial<Record<K, string | number | boolean>>[], context: Cxt, option?: Record<string, any>) => Promise<ED[T]['CreateMulti']['data']>;
-};
+import { AsyncContext } from "../store/AsyncRowStore";
+import { EntityDict } from "./Entity";
+export type Exportation<ED extends EntityDict, T extends keyof ED, K extends string, Cxt extends AsyncContext<ED>> = {
+    name: string;
+    id: string;
+    entity: T;
+    projection: ED[T]['Selection']['data'];
+    headers?: K[];
+    makeHeaders?: (dataList: Partial<ED[T]['Schema']>[]) => string[];
+    fn: (data: ED[T]['Schema'], context?: Cxt, properties?: Record<string, any>) => Promise<Partial<Record<string, string | number | boolean | null>>> | Partial<Record<string, string | number | boolean | null>>;
+};
+export type Importation<ED extends EntityDict, T extends keyof ED, K extends string, Cxt extends AsyncContext<ED>> = {
+    name: string;
+    id: string;
+    entity: T;
+    headers: K[];
+    fn: (data: Partial<Record<K, string | number | boolean>>[], context: Cxt, option?: Record<string, any>) => Promise<ED[T]['CreateMulti']['data']>;
+};

package/lib/types/RowStore.d.ts

@@ -1,19 +1,19 @@
-import { OperationResult, EntityDict } from './Entity';
-import { StorageSchema } from './Storage';
-import { AsyncContext } from '../store/AsyncRowStore';
-import { SyncContext } from '../store/SyncRowStore';
-import { OperateOption, SelectOption } from '.';
-export type TxnOption = {
-    isolationLevel: 'repeatable read' | 'serializable';
-};
-export type SelectionRewriter<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>, Op extends SelectOption> = (schema: StorageSchema<ED>, entity: keyof ED, selection: ED[keyof ED]['Selection'] | ED[keyof ED]['Aggregation'], context: Cxt, option: Op, isAggr?: true) => void | Promise<void>;
-export type OperationRewriter<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>, Op extends OperateOption> = (schema: StorageSchema<ED>, entity: keyof ED, operate: ED[keyof ED]['Operation'], context: Cxt, option: Op) => void | Promise<void>;
-export declare abstract class RowStore<ED extends EntityDict> {
-    protected storageSchema: StorageSchema<ED>;
-    constructor(storageSchema: StorageSchema<ED>);
-    abstract registerOperationRewriter(rewriter: OperationRewriter<ED, AsyncContext<ED> | SyncContext<ED>, SelectOption>): void;
-    abstract registerSelectionRewriter(rewriter: SelectionRewriter<ED, AsyncContext<ED> | SyncContext<ED>, OperateOption>): void;
-    getSchema(): StorageSchema<ED>;
-    mergeOperationResult(result: OperationResult<ED>, toBeMerged: OperationResult<ED>): void;
-    mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;
-}
+import { OperationResult, EntityDict } from './Entity';
+import { StorageSchema } from './Storage';
+import { AsyncContext } from '../store/AsyncRowStore';
+import { SyncContext } from '../store/SyncRowStore';
+import { OperateOption, SelectOption } from '.';
+export type TxnOption = {
+    isolationLevel: 'repeatable read' | 'serializable';
+};
+export type SelectionRewriter<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>, Op extends SelectOption> = (schema: StorageSchema<ED>, entity: keyof ED, selection: ED[keyof ED]['Selection'] | ED[keyof ED]['Aggregation'], context: Cxt, option: Op, isAggr?: true) => void | Promise<void>;
+export type OperationRewriter<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>, Op extends OperateOption> = (schema: StorageSchema<ED>, entity: keyof ED, operate: ED[keyof ED]['Operation'], context: Cxt, option: Op) => void | Promise<void>;
+export declare abstract class RowStore<ED extends EntityDict> {
+    protected storageSchema: StorageSchema<ED>;
+    constructor(storageSchema: StorageSchema<ED>);
+    abstract registerOperationRewriter(rewriter: OperationRewriter<ED, AsyncContext<ED> | SyncContext<ED>, SelectOption>): void;
+    abstract registerSelectionRewriter(rewriter: SelectionRewriter<ED, AsyncContext<ED> | SyncContext<ED>, OperateOption>): void;
+    getSchema(): StorageSchema<ED>;
+    mergeOperationResult(result: OperationResult<ED>, toBeMerged: OperationResult<ED>): void;
+    mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;
+}

package/lib/types/RowStore.js

@@ -1,33 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RowStore = void 0;
-const lodash_1 = require("../utils/lodash");
-class RowStore {
-    storageSchema;
-    constructor(storageSchema) {
-        this.storageSchema = storageSchema;
-    }
-    getSchema() {
-        return this.storageSchema;
-    }
-    mergeOperationResult(result, toBeMerged) {
-        for (const entity in toBeMerged) {
-            for (const action in toBeMerged[entity]) {
-                const value = (0, lodash_1.get)(result, `${entity}.${action}`);
-                if (typeof value === 'number') {
-                    (0, lodash_1.set)(result, `${entity}.${action}`, value + toBeMerged[entity][action]);
-                }
-                else {
-                    (0, lodash_1.set)(result, `${entity}.${action}`, toBeMerged[entity][action]);
-                }
-            }
-        }
-    }
-    mergeMultipleResults(toBeMerged) {
-        const result = {};
-        toBeMerged.forEach(ele => this.mergeOperationResult(result, ele));
-        return result;
-    }
-}
-exports.RowStore = RowStore;
-;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowStore = void 0;
+const lodash_1 = require("../utils/lodash");
+class RowStore {
+    storageSchema;
+    constructor(storageSchema) {
+        this.storageSchema = storageSchema;
+    }
+    getSchema() {
+        return this.storageSchema;
+    }
+    mergeOperationResult(result, toBeMerged) {
+        for (const entity in toBeMerged) {
+            for (const action in toBeMerged[entity]) {
+                const value = (0, lodash_1.get)(result, `${entity}.${action}`);
+                if (typeof value === 'number') {
+                    (0, lodash_1.set)(result, `${entity}.${action}`, value + toBeMerged[entity][action]);
+                }
+                else {
+                    (0, lodash_1.set)(result, `${entity}.${action}`, toBeMerged[entity][action]);
+                }
+            }
+        }
+    }
+    mergeMultipleResults(toBeMerged) {
+        const result = {};
+        toBeMerged.forEach(ele => this.mergeOperationResult(result, ele));
+        return result;
+    }
+}
+exports.RowStore = RowStore;
+;

package/lib/types/Storage.d.ts

@@ -1,58 +1,58 @@
-import { ActionType } from '.';
-import { EntityDict, EntityShape, InstinctiveAttributes } from './Entity';
-import { DataType, DataTypeParams } from './schema/DataTypes';
-export 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 | string[];
-    onRefDelete?: 'delete' | 'setNull' | 'ignore';
-    default?: string | number | boolean;
-    notNull?: boolean;
-    unique?: boolean;
-    sequenceStart?: number;
-    enumeration?: string[];
-}
-export type Attributes<SH extends EntityShape> = Omit<{
-    [attrName in keyof SH]: Attribute;
-}, InstinctiveAttributes>;
-export interface EntityConfig {
-}
-export 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;
-    toModi?: true;
-    inModi?: true;
-    static?: true;
-    actions: string[];
-    actionType: ActionType;
-    relation?: string[];
-    view?: true;
-    recursiveDepth?: number;
-}
-export type StorageSchema<ED extends EntityDict> = {
-    [K in keyof ED]: StorageDesc<ED[K]['OpSchema']>;
-};
+import { ActionType } from '.';
+import { EntityDict, EntityShape, InstinctiveAttributes } from './Entity';
+import { DataType, DataTypeParams } from './schema/DataTypes';
+export 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 | string[];
+    onRefDelete?: 'delete' | 'setNull' | 'ignore';
+    default?: string | number | boolean;
+    notNull?: boolean;
+    unique?: boolean;
+    sequenceStart?: number;
+    enumeration?: string[];
+}
+export type Attributes<SH extends EntityShape> = Omit<{
+    [attrName in keyof SH]: Attribute;
+}, InstinctiveAttributes>;
+export interface EntityConfig {
+}
+export 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;
+    toModi?: true;
+    inModi?: true;
+    static?: true;
+    actions: string[];
+    actionType: ActionType;
+    relation?: string[];
+    view?: true;
+    recursiveDepth?: number;
+}
+export type StorageSchema<ED extends EntityDict> = {
+    [K in keyof ED]: StorageDesc<ED[K]['OpSchema']>;
+};

package/lib/types/Style.d.ts

@@ -1,11 +1,11 @@
-import { EntityDict } from './Entity';
-import { EntityDict as BaseEntityDict } from '../base-app-domain';
-type ThemeColor = 'default' | 'success' | 'warning' | 'error' | 'primary' | 'danger';
-export type ColorDict<ED extends BaseEntityDict & EntityDict> = {
-    [T in keyof ED]?: {
-        [A in keyof ED[T]['OpSchema']]?: {
-            [E in ED[T]['OpSchema'][A]]?: ThemeColor | `#${string}`;
-        };
-    };
-};
-export {};
+import { EntityDict } from './Entity';
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+type ThemeColor = 'default' | 'success' | 'warning' | 'error' | 'primary' | 'danger';
+export type ColorDict<ED extends BaseEntityDict & EntityDict> = {
+    [T in keyof ED]?: {
+        [A in keyof ED[T]['OpSchema']]?: {
+            [E in ED[T]['OpSchema'][A]]?: ThemeColor | `#${string}`;
+        };
+    };
+};
+export {};

package/lib/types/Timer.d.ts

@@ -1,20 +1,20 @@
-import { RecurrenceRule, RecurrenceSpecDateRange, RecurrenceSpecObjLit } from 'node-schedule';
-import { EntityDict } from './Entity';
-import { AsyncContext } from '../store/AsyncRowStore';
-import { Watcher } from './Watcher';
-import { OperationResult } from '.';
-type FreeOperateFn<ED extends EntityDict, Cxt extends AsyncContext<ED>> = (context: Cxt) => Promise<OperationResult<ED>>;
-export type FreeRoutine<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
-    name: string;
-    routine: FreeOperateFn<ED, Cxt>;
-};
-export type FreeTimer<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
-    name: string;
-    cron: RecurrenceRule | RecurrenceSpecDateRange | RecurrenceSpecObjLit | Date | string | number;
-    timer: FreeOperateFn<ED, Cxt>;
-};
-export type Routine<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = FreeRoutine<ED, Cxt> | Watcher<ED, T, Cxt>;
-export type Timer<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = FreeTimer<ED, Cxt> | Watcher<ED, T, Cxt> & {
-    cron: RecurrenceRule | RecurrenceSpecDateRange | RecurrenceSpecObjLit | Date | string | number;
-};
-export {};
+import { RecurrenceRule, RecurrenceSpecDateRange, RecurrenceSpecObjLit } from 'node-schedule';
+import { EntityDict } from './Entity';
+import { AsyncContext } from '../store/AsyncRowStore';
+import { Watcher } from './Watcher';
+import { OperationResult } from '.';
+type FreeOperateFn<ED extends EntityDict, Cxt extends AsyncContext<ED>> = (context: Cxt) => Promise<OperationResult<ED>>;
+export type FreeRoutine<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
+    name: string;
+    routine: FreeOperateFn<ED, Cxt>;
+};
+export type FreeTimer<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
+    name: string;
+    cron: RecurrenceRule | RecurrenceSpecDateRange | RecurrenceSpecObjLit | Date | string | number;
+    timer: FreeOperateFn<ED, Cxt>;
+};
+export type Routine<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = FreeRoutine<ED, Cxt> | Watcher<ED, T, Cxt>;
+export type Timer<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = FreeTimer<ED, Cxt> | Watcher<ED, T, Cxt> & {
+    cron: RecurrenceRule | RecurrenceSpecDateRange | RecurrenceSpecObjLit | Date | string | number;
+};
+export {};