oak-domain 2.3.2 → 2.4.1

package/lib/types/Demand.d.ts

@@ -1,77 +1,77 @@
-import { RefOrExpression } from "./Expression";
-import { OneOf } from "./Polyfill";
-export declare const EXPRESSION_PREFIX = "$expr";
-export declare type NodeId = `node-${number}`;
-export declare type ExpressionKey = '$expr' | '$expr1' | '$expr2' | '$expr3' | '$expr4' | '$expr5' | '$expr6' | '$expr7' | '$expr8' | '$expr9' | '$expr10' | '$expr11' | '$expr12' | '$expr13' | '$expr14' | '$expr15' | '$expr16' | '$expr17' | '$expr18' | '$expr19' | '$expr20';
-export declare type ExprOp<A> = {
-    [K in ExpressionKey]: RefOrExpression<A>;
-};
-export declare type Q_NumberComparisonValue = number | OneOf<{
-    $gt: number;
-    $lt: number;
-    $gte: number;
-    $lte: number;
-    $eq: number;
-    $ne: number;
-    $in: number[];
-    $nin: number[];
-    $between: [number, number];
-}>;
-export declare type Q_StringComparisonValue = string | OneOf<{
-    $gt: string;
-    $lt: string;
-    $gte: string;
-    $lte: string;
-    $eq: string;
-    $ne: string;
-    $startsWith: string;
-    $endsWith: string;
-    $includes: string;
-    $in: string[];
-    $nin: string[];
-}>;
-export declare type Q_BooleanComparisonValue = boolean;
-export declare type Q_DateComparisonValue = Q_NumberComparisonValue;
-export declare type Q_EnumComparisonValue<E> = E | OneOf<{
-    $in: E[];
-    $nin: E[];
-}>;
-export declare type Q_ExistsValue = {
-    $exists: boolean;
-};
-export declare type Q_NumberValue = Q_NumberComparisonValue | Q_ExistsValue;
-export declare type Q_StringValue = Q_StringComparisonValue | Q_ExistsValue;
-export declare type Q_BooleanValue = Q_BooleanComparisonValue | Q_ExistsValue;
-export declare type Q_DateValue = Q_DateComparisonValue | Q_ExistsValue;
-export declare type Q_EnumValue<E> = Q_EnumComparisonValue<E> | Q_ExistsValue;
-export declare type Q_State<S> = S | {
-    $in: S[];
-} | {
-    $nin: S[];
-} | Q_ExistsValue;
-export declare type Q_FullTextValue = {
-    $search: string;
-    $language?: 'zh_CN' | 'en_US';
-};
-export declare type Q_FullTextKey = '$text';
-export declare type FulltextFilter = {
-    [F in Q_FullTextKey]?: Q_FullTextValue;
-};
-declare type Q_LogicKey = '$and' | '$or';
-declare type Q_LinearLogicKey = '$not';
-export declare type MakeFilterWrapper<F extends Object> = {
-    [Q in Q_LogicKey]?: Array<MakeFilterWrapper<F>>;
-} & {
-    [Q in Q_LinearLogicKey]?: MakeFilterWrapper<F>;
-} & Partial<F>;
-export declare type MakeFilter<F extends Object> = {
-    '#id'?: NodeId;
-} & MakeFilterWrapper<F>;
-export declare type RefAttr<A> = {
-    '#attr': A;
-} | {
-    '#refId': NodeId;
-    '#refAttr': string;
-};
-export declare function isRefAttrNode<A>(node: any): node is RefAttr<A>;
-export {};
+import { RefOrExpression } from "./Expression";
+import { OneOf } from "./Polyfill";
+export declare const EXPRESSION_PREFIX = "$expr";
+export type NodeId = `node-${number}`;
+export type ExpressionKey = '$expr' | '$expr1' | '$expr2' | '$expr3' | '$expr4' | '$expr5' | '$expr6' | '$expr7' | '$expr8' | '$expr9' | '$expr10' | '$expr11' | '$expr12' | '$expr13' | '$expr14' | '$expr15' | '$expr16' | '$expr17' | '$expr18' | '$expr19' | '$expr20';
+export type ExprOp<A> = {
+    [K in ExpressionKey]: RefOrExpression<A>;
+};
+export type Q_NumberComparisonValue = number | OneOf<{
+    $gt: number;
+    $lt: number;
+    $gte: number;
+    $lte: number;
+    $eq: number;
+    $ne: number;
+    $in: number[];
+    $nin: number[];
+    $between: [number, number];
+}>;
+export type Q_StringComparisonValue = string | OneOf<{
+    $gt: string;
+    $lt: string;
+    $gte: string;
+    $lte: string;
+    $eq: string;
+    $ne: string;
+    $startsWith: string;
+    $endsWith: string;
+    $includes: string;
+    $in: string[];
+    $nin: string[];
+}>;
+export type Q_BooleanComparisonValue = boolean;
+export type Q_DateComparisonValue = Q_NumberComparisonValue;
+export type Q_EnumComparisonValue<E> = E | OneOf<{
+    $in: E[];
+    $nin: E[];
+}>;
+export type Q_ExistsValue = {
+    $exists: boolean;
+};
+export type Q_NumberValue = Q_NumberComparisonValue | Q_ExistsValue;
+export type Q_StringValue = Q_StringComparisonValue | Q_ExistsValue;
+export type Q_BooleanValue = Q_BooleanComparisonValue | Q_ExistsValue;
+export type Q_DateValue = Q_DateComparisonValue | Q_ExistsValue;
+export type Q_EnumValue<E> = Q_EnumComparisonValue<E> | Q_ExistsValue;
+export type Q_State<S> = S | {
+    $in: S[];
+} | {
+    $nin: S[];
+} | Q_ExistsValue;
+export type Q_FullTextValue = {
+    $search: string;
+    $language?: 'zh_CN' | 'en_US';
+};
+export type Q_FullTextKey = '$text';
+export type FulltextFilter = {
+    [F in Q_FullTextKey]?: Q_FullTextValue;
+};
+type Q_LogicKey = '$and' | '$or';
+type Q_LinearLogicKey = '$not';
+export type MakeFilterWrapper<F extends Object> = {
+    [Q in Q_LogicKey]?: Array<MakeFilterWrapper<F>>;
+} & {
+    [Q in Q_LinearLogicKey]?: MakeFilterWrapper<F>;
+} & Partial<F>;
+export type MakeFilter<F extends Object> = {
+    '#id'?: NodeId;
+} & MakeFilterWrapper<F>;
+export type RefAttr<A> = {
+    '#attr': A;
+} | {
+    '#refId': NodeId;
+    '#refAttr': string;
+};
+export declare function isRefAttrNode<A>(node: any): node is RefAttr<A>;
+export {};

package/lib/types/Demand.js

@@ -1,9 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRefAttrNode = exports.EXPRESSION_PREFIX = void 0;
-exports.EXPRESSION_PREFIX = '$expr';
-function isRefAttrNode(node) {
-    return node.hasOwnProperty('#attr') || (node.hasOwnProperty('#refId') && node.hasOwnProperty('#refAttr'));
-}
-exports.isRefAttrNode = isRefAttrNode;
-;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRefAttrNode = exports.EXPRESSION_PREFIX = void 0;
+exports.EXPRESSION_PREFIX = '$expr';
+function isRefAttrNode(node) {
+    return node.hasOwnProperty('#attr') || (node.hasOwnProperty('#refId') && node.hasOwnProperty('#refAttr'));
+}
+exports.isRefAttrNode = isRefAttrNode;
+;

package/lib/types/Endpoint.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders, IncomingMessage } from "http";
+import { AsyncContext } from "../store/AsyncRowStore";
+import { EntityDict } from "./Entity";
+export interface EndpointItem<ED extends EntityDict, BackCxt extends AsyncContext<ED>> {
+    name: string;
+    params?: string[];
+    method: 'get' | 'post' | 'put' | 'delete';
+    fn: (context: BackCxt, params: Record<string, string>, headers: IncomingHttpHeaders, req: IncomingMessage, body?: any) => Promise<any>;
+}
+export type Endpoint<ED extends EntityDict, BackCxt extends AsyncContext<ED>> = EndpointItem<ED, BackCxt> | EndpointItem<ED, BackCxt>[];

package/lib/types/Endpoint.js

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

package/lib/types/Entity.d.ts

@@ -1,190 +1,176 @@
-import { GenericAction } from '../actions/action';
-import { ExprOp, MakeFilter, NodeId } from './Demand';
-import { OneOf } from './Polyfill';
-import { PrimaryKey, Sequence } from './DataType';
-declare type TriggerDataAttributeType = '$$triggerData$$';
-declare type TriggerTimestampAttributeType = '$$triggerTimestamp$$';
-declare type PrimaryKeyAttributeType = 'id';
-declare type CreateAtAttributeType = '$$createAt$$';
-declare type UpdateAtAttributeType = '$$updateAt$$';
-declare type DeleteAtAttributeType = '$$deleteAt$$';
-declare type SeqAttributeType = '$$seq$$';
-export declare const TriggerDataAttribute = "$$triggerData$$";
-export declare const TriggerTimestampAttribute = "$$triggerTimestamp$$";
-export declare const PrimaryKeyAttribute = "id";
-export declare const CreateAtAttribute = "$$createAt$$";
-export declare const UpdateAtAttribute = "$$updateAt$$";
-export declare const DeleteAtAttribute = "$$deleteAt$$";
-export declare const SeqAttribute = "$$seq$$";
-export declare type InstinctiveAttributes = PrimaryKeyAttributeType | CreateAtAttributeType | UpdateAtAttributeType | DeleteAtAttributeType | TriggerDataAttributeType | TriggerTimestampAttributeType | SeqAttributeType;
-export declare const initinctiveAttributes: string[];
-export declare type Filter<A extends string, F extends Object | undefined = undefined> = {
-    filter?: A extends 'create' ? undefined : F;
-    indexFrom?: A extends 'create' ? undefined : number;
-    count?: A extends 'create' ? undefined : number;
-};
-export declare type SelectOption = {
-    dontCollect?: boolean;
-    blockTrigger?: true;
-    obscure?: boolean;
-    forUpdate?: true;
-    includedDeleted?: true;
-    dummy?: 1;
-};
-export declare type OperateOption = {
-    blockTrigger?: true;
-    dontCollect?: boolean;
-    dontCreateOper?: boolean;
-    dontCreateModi?: boolean;
-    allowExists?: boolean;
-    modiParentId?: string;
-    modiParentEntity?: string;
-    dummy?: 1;
-};
-export declare type FormUpdateData<SH extends GeneralEntityShape> = Partial<{
-    [K in keyof Omit<SH, InstinctiveAttributes>]: SH[K] | null;
-}>;
-export declare type FormCreateData<SH extends GeneralEntityShape> = Omit<SH, InstinctiveAttributes> & {
-    id: string;
-};
-export declare type Operation<A extends GenericAction | string, DATA extends Object, FILTER extends Object | undefined = undefined, SORTER extends Object | undefined = undefined> = {
-    id?: string;
-    action: A;
-    data: DATA;
-    sorter?: SORTER;
-} & Filter<A, FILTER>;
-export declare type Selection<DATA extends Object, FILTER extends Object | undefined = undefined, SORT extends Object | undefined = undefined> = Operation<'select', DATA, FILTER, SORT>;
-export interface EntityShape {
-    id: PrimaryKey;
-    $$seq$$: Sequence;
-    $$createAt$$: number | Date;
-    $$updateAt$$: number | Date;
-    $$deleteAt$$?: number | Date | null;
-}
-export interface FileCarrierEntityShape extends EntityShape {
-}
-interface GeneralEntityShape extends EntityShape {
-    [K: string]: any;
-}
-export declare type MakeAction<A extends string> = A;
-export interface EntityDef {
-    Schema: GeneralEntityShape;
-    OpSchema: GeneralEntityShape;
-    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']>;
-    CreateMulti: DeduceCreateMultipleOperation<this['Schema']>;
-    Update: DeduceUpdateOperation<this['Schema']>;
-    Remove: DeduceRemoveOperation<this['Schema']>;
-}
-export interface EntityDict {
-    [E: string]: EntityDef;
-}
-export interface OtmSubProjection extends Omit<DeduceSelection<any>, 'action'> {
-    $entity: string;
-}
-declare type DeduceProjection<SH extends GeneralEntityShape> = {
-    '#id'?: NodeId;
-} & {
-    [K in keyof SH]?: number | OtmSubProjection | any;
-} & 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;
-};
-export declare type DeduceFilter<SH extends GeneralEntityShape> = MakeFilter<AttrFilter<SH> & ExprOp<keyof SH>>;
-export declare type DeduceSorterAttr<SH extends GeneralEntityShape> = OneOf<{
-    [K: string]: number | object | undefined;
-} & ExprOp<keyof SH>>;
-export declare type DeduceSorterItem<SH extends GeneralEntityShape> = {
-    $attr: DeduceSorterAttr<SH>;
-    $direction?: "asc" | "desc";
-};
-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;
-} & {
-    [k in keyof Omit<SH, InstinctiveAttributes>]?: any;
-};
-export declare type DeduceCreateSingleOperation<SH extends GeneralEntityShape> = Operation<'create', DeduceCreateOperationData<SH>>;
-export declare type DeduceCreateMultipleOperation<SH extends GeneralEntityShape> = Operation<'create', Array<DeduceCreateOperationData<SH>>>;
-export declare type DeduceCreateOperation<SH extends GeneralEntityShape> = DeduceCreateSingleOperation<SH> | DeduceCreateMultipleOperation<SH>;
-export declare type DeduceUpdateOperationData<SH extends GeneralEntityShape> = {
-    [k in keyof Omit<SH, InstinctiveAttributes>]?: any;
-};
-export declare type DeduceUpdateOperation<SH extends GeneralEntityShape> = Operation<'update' | string, DeduceUpdateOperationData<SH>, DeduceFilter<SH>, DeduceSorter<SH>>;
-export declare type DeduceRemoveOperationData<SH extends GeneralEntityShape> = {
-    [A in keyof Omit<SH, InstinctiveAttributes>]?: any;
-};
-export declare type DeduceRemoveOperation<SH extends GeneralEntityShape> = Operation<'remove', DeduceRemoveOperationData<SH>, DeduceFilter<SH>, DeduceSorter<SH>>;
-export declare type DeduceOperation<SH extends GeneralEntityShape> = DeduceCreateOperation<SH> | DeduceUpdateOperation<SH> | DeduceRemoveOperation<SH>;
-export declare type CreateOpResult<ED extends EntityDict, T extends keyof ED> = {
-    a: 'c';
-    e: T;
-    d: ED[T]['OpSchema'] | ED[T]['OpSchema'][];
-};
-export declare type UpdateOpResult<ED extends EntityDict, T extends keyof ED> = {
-    a: 'u';
-    e: T;
-    d: DeduceUpdateOperationData<ED[T]['Schema']>;
-    f?: DeduceFilter<ED[T]['Schema']>;
-};
-export declare type RemoveOpResult<ED extends EntityDict, T extends keyof ED> = {
-    a: 'r';
-    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: {
-        [T in keyof ED]?: {
-            [ID: string]: ED[T]['OpSchema'];
-        };
-    };
-};
-export declare type OpRecord<ED extends EntityDict> = CreateOpResult<ED, keyof ED> | UpdateOpResult<ED, keyof ED> | RemoveOpResult<ED, keyof ED> | SelectOpResult<ED>;
-export declare type OperationResult<ED extends EntityDict> = {
-    [K in keyof ED]?: {
-        [A in ED[K]['Action']]?: number;
-    };
-};
-export declare type ActionType = 'readOnly' | 'appendOnly' | 'excludeUpdate' | 'excludeRemove' | 'crud';
-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 {};
+import { PrimaryKey, Sequence } from './DataType';
+type TriggerDataAttributeType = '$$triggerData$$';
+type TriggerTimestampAttributeType = '$$triggerTimestamp$$';
+type PrimaryKeyAttributeType = 'id';
+type CreateAtAttributeType = '$$createAt$$';
+type UpdateAtAttributeType = '$$updateAt$$';
+type DeleteAtAttributeType = '$$deleteAt$$';
+type SeqAttributeType = '$$seq$$';
+export declare const TriggerDataAttribute = "$$triggerData$$";
+export declare const TriggerTimestampAttribute = "$$triggerTimestamp$$";
+export declare const PrimaryKeyAttribute = "id";
+export declare const CreateAtAttribute = "$$createAt$$";
+export declare const UpdateAtAttribute = "$$updateAt$$";
+export declare const DeleteAtAttribute = "$$deleteAt$$";
+export declare const SeqAttribute = "$$seq$$";
+export type InstinctiveAttributes = PrimaryKeyAttributeType | CreateAtAttributeType | UpdateAtAttributeType | DeleteAtAttributeType | TriggerDataAttributeType | TriggerTimestampAttributeType | SeqAttributeType;
+export declare const initinctiveAttributes: string[];
+type FilterPart<A extends string, F extends Object | undefined> = {
+    filter?: A extends 'create' ? undefined : F;
+    indexFrom?: A extends 'create' ? undefined : number;
+    count?: A extends 'create' ? undefined : number;
+};
+export type SelectOption = {
+    dontCollect?: boolean;
+    blockTrigger?: true;
+    obscure?: boolean;
+    forUpdate?: true;
+    includedDeleted?: true;
+    dummy?: 1;
+};
+export type OperateOption = {
+    blockTrigger?: true;
+    dontCollect?: boolean;
+    dontCreateOper?: boolean;
+    dontCreateModi?: boolean;
+    allowExists?: boolean;
+    modiParentId?: string;
+    modiParentEntity?: string;
+    dummy?: 1;
+};
+export type FormUpdateData<SH extends GeneralEntityShape> = Partial<{
+    [K in keyof Omit<SH, InstinctiveAttributes>]: SH[K] | null;
+}>;
+export type FormCreateData<SH extends GeneralEntityShape> = Partial<Omit<SH, InstinctiveAttributes>> & {
+    id: string;
+};
+export type Operation<A extends string, D extends Projection, F extends Filter | undefined = undefined, S extends Sorter | undefined = undefined> = {
+    id?: string;
+    action: A;
+    data: D;
+    sorter?: S;
+} & FilterPart<A, F>;
+export interface EntityShape {
+    id: PrimaryKey;
+    $$seq$$: Sequence;
+    $$createAt$$: number | Date;
+    $$updateAt$$: number | Date;
+    $$deleteAt$$?: number | Date | null;
+}
+interface GeneralEntityShape extends EntityShape {
+    [K: string]: any;
+}
+export type MakeAction<A extends string> = A;
+export interface EntityDef {
+    Schema: GeneralEntityShape;
+    OpSchema: GeneralEntityShape;
+    Action: string;
+    ParticularAction?: string;
+    Selection: Omit<Operation<'select', Projection, Filter, Sorter>, 'action'>;
+    Aggregation: Omit<DeduceAggregation<Projection, Filter, Sorter>, 'action'>;
+    Operation: CUDOperation;
+    Create: CreateOperation;
+    CreateSingle: CreateSingleOperation;
+    CreateMulti: CreateMultipleOperation;
+    Update: UpdateOperation;
+    Remove: RemoveOperation;
+    Relation?: string;
+}
+export interface EntityDict {
+    [E: string]: EntityDef;
+}
+export interface OtmSubProjection extends Omit<Operation<'select', any, any, any>, 'action'> {
+    $entity: string;
+}
+export type AggregationOp = `#max-${number}` | `#min-${number}` | `#avg-${number}` | `#count-${number}` | `#sum-${number}`;
+export type DeduceAggregationData<P extends Projection> = {
+    [A in AggregationOp]?: P;
+} & {
+    '#aggr'?: P;
+};
+export type AggregationResult<SH extends GeneralEntityShape> = Array<{
+    [A in AggregationOp]?: number | string;
+} & {
+    '#data'?: Partial<SH>;
+}>;
+export type AttrFilter<SH extends GeneralEntityShape> = {
+    [K in keyof SH]?: any;
+};
+type SortAttr = {
+    [K: string]: any;
+};
+type SorterItem = {
+    $attr: SortAttr;
+    $direction?: "asc" | "desc";
+};
+type Sorter = Array<SorterItem>;
+type Filter = {
+    [K: string]: any;
+};
+type Projection = {
+    [K: string]: any;
+};
+export type DeduceAggregation<P extends Projection, F extends Filter, S extends Sorter> = Omit<Operation<'aggregate', DeduceAggregationData<P>, F, S>, 'action'>;
+type CreateOperationData = {
+    id: string;
+    [K: string]: any;
+};
+type CreateSingleOperation = Operation<'create', CreateOperationData, undefined, undefined>;
+type CreateMultipleOperation = Operation<'create', Array<CreateOperationData>, undefined, undefined>;
+type CreateOperation = CreateSingleOperation | CreateMultipleOperation;
+type UpdateOperationData = {
+    id?: never;
+    [k: string]: any;
+};
+export type UpdateOperation = Operation<string, UpdateOperationData, Filter, Sorter>;
+type RemoveOperationData = {
+    [k: string]: any;
+};
+export type RemoveOperation = Operation<'remove', RemoveOperationData, Filter, Sorter>;
+export type CUDOperation = CreateOperation | UpdateOperation | RemoveOperation;
+export type CreateOpResult<ED extends EntityDict, T extends keyof ED> = {
+    a: 'c';
+    e: T;
+    d: ED[T]['OpSchema'] | ED[T]['OpSchema'][];
+};
+export type UpdateOpResult<ED extends EntityDict, T extends keyof ED> = {
+    a: 'u';
+    e: T;
+    d: UpdateOperationData;
+    f?: Filter;
+};
+export type RemoveOpResult<ED extends EntityDict, T extends keyof ED> = {
+    a: 'r';
+    e: T;
+    f?: Filter;
+};
+export type RelationHierarchy<R extends string> = {
+    [K in R]?: R[];
+};
+export type CascadeRelationItem = {
+    cascadePath: string;
+    relations?: string[];
+};
+export type CascadeRelationAuth<R extends string> = {
+    [K in R]?: CascadeRelationItem | (CascadeRelationItem | CascadeRelationItem[])[];
+};
+export type SelectOpResult<ED extends EntityDict> = {
+    a: 's';
+    d: {
+        [T in keyof ED]?: {
+            [ID: string]: ED[T]['OpSchema'];
+        };
+    };
+};
+export type OpRecord<ED extends EntityDict> = CreateOpResult<ED, keyof ED> | UpdateOpResult<ED, keyof ED> | RemoveOpResult<ED, keyof ED> | SelectOpResult<ED>;
+export type OperationResult<ED extends EntityDict> = {
+    [K in keyof ED]?: {
+        [A in ED[K]['Action']]?: number;
+    };
+};
+export type ActionType = 'readOnly' | 'appendOnly' | 'excludeUpdate' | 'excludeRemove' | 'crud';
+export type Configuration = {
+    actionType?: ActionType;
+    static?: boolean;
+};
+export {};

package/lib/types/Entity.js

@@ -1,15 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initinctiveAttributes = exports.SeqAttribute = exports.DeleteAtAttribute = exports.UpdateAtAttribute = exports.CreateAtAttribute = exports.PrimaryKeyAttribute = exports.TriggerTimestampAttribute = exports.TriggerDataAttribute = void 0;
-exports.TriggerDataAttribute = '$$triggerData$$';
-exports.TriggerTimestampAttribute = '$$triggerTimestamp$$';
-exports.PrimaryKeyAttribute = 'id';
-exports.CreateAtAttribute = '$$createAt$$';
-exports.UpdateAtAttribute = '$$updateAt$$';
-exports.DeleteAtAttribute = '$$deleteAt$$';
-exports.SeqAttribute = '$$seq$$';
-exports.initinctiveAttributes = [exports.PrimaryKeyAttribute, exports.TriggerDataAttribute, exports.TriggerTimestampAttribute, exports.CreateAtAttribute, exports.UpdateAtAttribute, exports.DeleteAtAttribute, exports.SeqAttribute];
-;
-;
-;
-;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initinctiveAttributes = exports.SeqAttribute = exports.DeleteAtAttribute = exports.UpdateAtAttribute = exports.CreateAtAttribute = exports.PrimaryKeyAttribute = exports.TriggerTimestampAttribute = exports.TriggerDataAttribute = void 0;
+exports.TriggerDataAttribute = '$$triggerData$$';
+exports.TriggerTimestampAttribute = '$$triggerTimestamp$$';
+exports.PrimaryKeyAttribute = 'id';
+exports.CreateAtAttribute = '$$createAt$$';
+exports.UpdateAtAttribute = '$$updateAt$$';
+exports.DeleteAtAttribute = '$$deleteAt$$';
+exports.SeqAttribute = '$$seq$$';
+exports.initinctiveAttributes = [exports.PrimaryKeyAttribute, exports.TriggerDataAttribute, exports.TriggerTimestampAttribute, exports.CreateAtAttribute, exports.UpdateAtAttribute, exports.DeleteAtAttribute, exports.SeqAttribute];
+;
+;
+;