From 0b01f8da3cdf0a4693761a610c313be6ad2ede6f Mon Sep 17 00:00:00 2001
From: Xc <chinawraith@163.com>
Date: Wed, 10 Apr 2024 15:32:33 +0800
Subject: [PATCH] =?UTF-8?q?=E7=AE=80=E5=8C=96=E4=BA=86=E7=BC=96=E8=AF=91?=
 =?UTF-8?q?=E5=A3=B0=E6=98=8E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 es/AspectDict.d.ts  | 21 +++++++++++----------
 es/crud.d.ts        | 20 ++++++++++----------
 es/relation.d.ts    |  4 ++--
 lib/AspectDict.d.ts | 21 +++++++++++----------
 lib/crud.d.ts       | 20 ++++++++++----------
 lib/relation.d.ts   |  4 ++--
 src/AspectDict.ts   | 22 ++++++++++++----------
 src/crud.ts         | 17 ++++++-----------
 src/relation.ts     |  5 ++---
 9 files changed, 66 insertions(+), 68 deletions(-)

diff --git a/es/AspectDict.d.ts b/es/AspectDict.d.ts
index 8cc8bac..8b820fe 100644
--- a/es/AspectDict.d.ts
+++ b/es/AspectDict.d.ts
@@ -2,18 +2,18 @@ import { EntityDict, OperateOption, SelectOption, OperationResult, AggregationRe
 import { AmapInstance } from "oak-external-sdk/lib/service/amap/Amap";
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { AsyncContext } from "oak-domain/lib/store/AsyncRowStore";
-export declare type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = {
+export declare type AspectDict<ED extends EntityDict & BaseEntityDict> = {
     operate: <T extends keyof ED, OP extends OperateOption>(params: {
         entity: T;
         operation: ED[T]['Operation'] | ED[T]['Operation'][];
         option?: OP;
-    }, context: Cxt) => Promise<OperationResult<ED>[] | OperationResult<ED>>;
+    }, context: AsyncContext<ED>) => Promise<OperationResult<ED>[] | OperationResult<ED>>;
     select: <T extends keyof ED, OP extends SelectOption>(params: {
         entity: T;
         selection: ED[T]['Selection'];
         option?: OP;
         getCount?: true;
-    }, context: Cxt) => Promise<{
+    }, context: AsyncContext<ED>) => Promise<{
         data: Record<string, any>;
         total?: number;
     }>;
@@ -21,17 +21,17 @@ export declare type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt
         entity: T;
         aggregation: ED[T]['Aggregation'];
         option?: OP;
-    }, context: Cxt) => Promise<AggregationResult<ED[T]['Schema']>>;
+    }, context: AsyncContext<ED>) => Promise<AggregationResult<ED[T]['Schema']>>;
     count: <T extends keyof ED, OP extends SelectOption>(params: {
         entity: T;
         selection: Pick<ED[T]['Selection'], 'filter'>;
         option?: OP;
-    }, context: Cxt) => Promise<number>;
+    }, context: AsyncContext<ED>) => Promise<number>;
     fetchRows: <OP extends SelectOption>(params: Array<{
         entity: keyof ED;
         selection: ED[keyof ED]['Selection'];
         option?: OP;
-    }>, context: Cxt) => Promise<void>;
+    }>, context: AsyncContext<ED>) => Promise<void>;
     amap: <T extends 'getDrivingPath' | 'regeo' | 'ipLoc' | 'getDistrict' | 'geocode'>(params: {
         key: string;
         method: T;
@@ -41,16 +41,16 @@ export declare type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt
         namespace: string | string[];
         locale: string;
     }) => Promise<any>;
-    importEntity: (params: FormData, context: Cxt) => Promise<void | ArrayBuffer>;
+    importEntity: (params: FormData, context: AsyncContext<ED>) => Promise<void | ArrayBuffer>;
     exportEntity: <T extends keyof ED>(params: {
         entity: T;
         id: string;
         filter?: ED[T]['Selection']['filter'];
         properties?: Record<string, any>;
-    }, context: Cxt) => Promise<ArrayBuffer>;
+    }, context: AsyncContext<ED>) => Promise<ArrayBuffer>;
     getImportationTemplate: (params: {
         id: string;
-    }, context: Cxt) => Promise<ArrayBuffer>;
+    }, context: AsyncContext<ED>) => Promise<ArrayBuffer>;
     searchPoi: (options: {
         value: string;
         areaCode?: string;
@@ -66,8 +66,9 @@ export declare type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt
     }[]>;
     loadRelations: (params: {
         entities: (keyof ED)[];
-    }, context: Cxt) => Promise<ED['userRelation']['OpSchema'][]>;
+    }, context: AsyncContext<ED>) => Promise<ED['userRelation']['OpSchema'][]>;
     crossBridge: (params: {
         url: string;
     }) => Promise<ReadableStream<Uint8Array>>;
 };
+export default AspectDict;
diff --git a/es/crud.d.ts b/es/crud.d.ts
index 3ec5bed..86c95c1 100644
--- a/es/crud.d.ts
+++ b/es/crud.d.ts
@@ -1,33 +1,33 @@
 import { OperateOption, EntityDict, SelectOption } from 'oak-domain/lib/types';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
-export declare function operate<ED extends BaseEntityDict & EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends OperateOption>(params: {
+export declare function operate<ED extends BaseEntityDict & EntityDict, T extends keyof ED, OP extends OperateOption>(params: {
     entity: T;
     operation: ED[T]['Operation'] | ED[T]['Operation'][];
     option?: OP;
-}, context: Cxt): Promise<import("oak-domain/lib/types").OperationResult<ED> | Awaited<import("oak-domain/lib/types").OperationResult<ED>>[]>;
-export declare function select<ED extends BaseEntityDict & EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends SelectOption>(params: {
+}, context: AsyncContext<ED>): Promise<import("oak-domain/lib/types").OperationResult<ED> | Awaited<import("oak-domain/lib/types").OperationResult<ED>>[]>;
+export declare function select<ED extends BaseEntityDict & EntityDict, T extends keyof ED, OP extends SelectOption>(params: {
     entity: T;
     selection: ED[T]['Selection'];
     option?: OP;
     getCount?: true;
     maxCount?: number;
-}, context: Cxt): Promise<{
+}, context: AsyncContext<ED>): Promise<{
     data: Record<string, any>;
     total?: number | undefined;
 }>;
-export declare function aggregate<ED extends BaseEntityDict & EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends SelectOption>(params: {
+export declare function aggregate<ED extends BaseEntityDict & EntityDict, T extends keyof ED, OP extends SelectOption>(params: {
     entity: T;
     aggregation: ED[T]['Aggregation'];
     option?: OP;
-}, context: Cxt): Promise<import("oak-domain/lib/types").AggregationResult<ED[T]["Schema"]>>;
-export declare function fetchRows<ED extends EntityDict & BaseEntityDict, OP extends SelectOption, Cxt extends AsyncContext<ED>>(params: Array<{
+}, context: AsyncContext<ED>): Promise<import("oak-domain/lib/types").AggregationResult<ED[T]["Schema"]>>;
+export declare function fetchRows<ED extends EntityDict & BaseEntityDict, OP extends SelectOption>(params: Array<{
     entity: keyof ED;
     selection: ED[keyof ED]['Selection'];
     option?: OP;
-}>, context: Cxt): Promise<void>;
-export declare function count<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends SelectOption>(params: {
+}>, context: AsyncContext<ED>): Promise<void>;
+export declare function count<ED extends EntityDict & BaseEntityDict, T extends keyof ED, OP extends SelectOption>(params: {
     entity: T;
     selection: Pick<ED[T]['Selection'], 'filter'>;
     option?: OP;
-}, context: Cxt): Promise<number>;
+}, context: AsyncContext<ED>): Promise<number>;
diff --git a/es/relation.d.ts b/es/relation.d.ts
index b748e03..900fb0f 100644
--- a/es/relation.d.ts
+++ b/es/relation.d.ts
@@ -1,6 +1,6 @@
 import { EntityDict } from 'oak-domain/lib/types';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
-export declare function loadRelations<ED extends BaseEntityDict & EntityDict, Cxt extends AsyncContext<ED>>(params: {
+export declare function loadRelations<ED extends BaseEntityDict & EntityDict>(params: {
     entities: (keyof ED)[];
-}, context: Cxt): Promise<ED["userRelation"]["OpSchema"][]>;
+}, context: AsyncContext<ED>): Promise<ED["userRelation"]["OpSchema"][]>;
diff --git a/lib/AspectDict.d.ts b/lib/AspectDict.d.ts
index 8cc8bac..8b820fe 100644
--- a/lib/AspectDict.d.ts
+++ b/lib/AspectDict.d.ts
@@ -2,18 +2,18 @@ import { EntityDict, OperateOption, SelectOption, OperationResult, AggregationRe
 import { AmapInstance } from "oak-external-sdk/lib/service/amap/Amap";
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { AsyncContext } from "oak-domain/lib/store/AsyncRowStore";
-export declare type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = {
+export declare type AspectDict<ED extends EntityDict & BaseEntityDict> = {
     operate: <T extends keyof ED, OP extends OperateOption>(params: {
         entity: T;
         operation: ED[T]['Operation'] | ED[T]['Operation'][];
         option?: OP;
-    }, context: Cxt) => Promise<OperationResult<ED>[] | OperationResult<ED>>;
+    }, context: AsyncContext<ED>) => Promise<OperationResult<ED>[] | OperationResult<ED>>;
     select: <T extends keyof ED, OP extends SelectOption>(params: {
         entity: T;
         selection: ED[T]['Selection'];
         option?: OP;
         getCount?: true;
-    }, context: Cxt) => Promise<{
+    }, context: AsyncContext<ED>) => Promise<{
         data: Record<string, any>;
         total?: number;
     }>;
@@ -21,17 +21,17 @@ export declare type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt
         entity: T;
         aggregation: ED[T]['Aggregation'];
         option?: OP;
-    }, context: Cxt) => Promise<AggregationResult<ED[T]['Schema']>>;
+    }, context: AsyncContext<ED>) => Promise<AggregationResult<ED[T]['Schema']>>;
     count: <T extends keyof ED, OP extends SelectOption>(params: {
         entity: T;
         selection: Pick<ED[T]['Selection'], 'filter'>;
         option?: OP;
-    }, context: Cxt) => Promise<number>;
+    }, context: AsyncContext<ED>) => Promise<number>;
     fetchRows: <OP extends SelectOption>(params: Array<{
         entity: keyof ED;
         selection: ED[keyof ED]['Selection'];
         option?: OP;
-    }>, context: Cxt) => Promise<void>;
+    }>, context: AsyncContext<ED>) => Promise<void>;
     amap: <T extends 'getDrivingPath' | 'regeo' | 'ipLoc' | 'getDistrict' | 'geocode'>(params: {
         key: string;
         method: T;
@@ -41,16 +41,16 @@ export declare type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt
         namespace: string | string[];
         locale: string;
     }) => Promise<any>;
-    importEntity: (params: FormData, context: Cxt) => Promise<void | ArrayBuffer>;
+    importEntity: (params: FormData, context: AsyncContext<ED>) => Promise<void | ArrayBuffer>;
     exportEntity: <T extends keyof ED>(params: {
         entity: T;
         id: string;
         filter?: ED[T]['Selection']['filter'];
         properties?: Record<string, any>;
-    }, context: Cxt) => Promise<ArrayBuffer>;
+    }, context: AsyncContext<ED>) => Promise<ArrayBuffer>;
     getImportationTemplate: (params: {
         id: string;
-    }, context: Cxt) => Promise<ArrayBuffer>;
+    }, context: AsyncContext<ED>) => Promise<ArrayBuffer>;
     searchPoi: (options: {
         value: string;
         areaCode?: string;
@@ -66,8 +66,9 @@ export declare type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt
     }[]>;
     loadRelations: (params: {
         entities: (keyof ED)[];
-    }, context: Cxt) => Promise<ED['userRelation']['OpSchema'][]>;
+    }, context: AsyncContext<ED>) => Promise<ED['userRelation']['OpSchema'][]>;
     crossBridge: (params: {
         url: string;
     }) => Promise<ReadableStream<Uint8Array>>;
 };
+export default AspectDict;
diff --git a/lib/crud.d.ts b/lib/crud.d.ts
index 3ec5bed..86c95c1 100644
--- a/lib/crud.d.ts
+++ b/lib/crud.d.ts
@@ -1,33 +1,33 @@
 import { OperateOption, EntityDict, SelectOption } from 'oak-domain/lib/types';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
-export declare function operate<ED extends BaseEntityDict & EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends OperateOption>(params: {
+export declare function operate<ED extends BaseEntityDict & EntityDict, T extends keyof ED, OP extends OperateOption>(params: {
     entity: T;
     operation: ED[T]['Operation'] | ED[T]['Operation'][];
     option?: OP;
-}, context: Cxt): Promise<import("oak-domain/lib/types").OperationResult<ED> | Awaited<import("oak-domain/lib/types").OperationResult<ED>>[]>;
-export declare function select<ED extends BaseEntityDict & EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends SelectOption>(params: {
+}, context: AsyncContext<ED>): Promise<import("oak-domain/lib/types").OperationResult<ED> | Awaited<import("oak-domain/lib/types").OperationResult<ED>>[]>;
+export declare function select<ED extends BaseEntityDict & EntityDict, T extends keyof ED, OP extends SelectOption>(params: {
     entity: T;
     selection: ED[T]['Selection'];
     option?: OP;
     getCount?: true;
     maxCount?: number;
-}, context: Cxt): Promise<{
+}, context: AsyncContext<ED>): Promise<{
     data: Record<string, any>;
     total?: number | undefined;
 }>;
-export declare function aggregate<ED extends BaseEntityDict & EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends SelectOption>(params: {
+export declare function aggregate<ED extends BaseEntityDict & EntityDict, T extends keyof ED, OP extends SelectOption>(params: {
     entity: T;
     aggregation: ED[T]['Aggregation'];
     option?: OP;
-}, context: Cxt): Promise<import("oak-domain/lib/types").AggregationResult<ED[T]["Schema"]>>;
-export declare function fetchRows<ED extends EntityDict & BaseEntityDict, OP extends SelectOption, Cxt extends AsyncContext<ED>>(params: Array<{
+}, context: AsyncContext<ED>): Promise<import("oak-domain/lib/types").AggregationResult<ED[T]["Schema"]>>;
+export declare function fetchRows<ED extends EntityDict & BaseEntityDict, OP extends SelectOption>(params: Array<{
     entity: keyof ED;
     selection: ED[keyof ED]['Selection'];
     option?: OP;
-}>, context: Cxt): Promise<void>;
-export declare function count<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends SelectOption>(params: {
+}>, context: AsyncContext<ED>): Promise<void>;
+export declare function count<ED extends EntityDict & BaseEntityDict, T extends keyof ED, OP extends SelectOption>(params: {
     entity: T;
     selection: Pick<ED[T]['Selection'], 'filter'>;
     option?: OP;
-}, context: Cxt): Promise<number>;
+}, context: AsyncContext<ED>): Promise<number>;
diff --git a/lib/relation.d.ts b/lib/relation.d.ts
index b748e03..900fb0f 100644
--- a/lib/relation.d.ts
+++ b/lib/relation.d.ts
@@ -1,6 +1,6 @@
 import { EntityDict } from 'oak-domain/lib/types';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
-export declare function loadRelations<ED extends BaseEntityDict & EntityDict, Cxt extends AsyncContext<ED>>(params: {
+export declare function loadRelations<ED extends BaseEntityDict & EntityDict>(params: {
     entities: (keyof ED)[];
-}, context: Cxt): Promise<ED["userRelation"]["OpSchema"][]>;
+}, context: AsyncContext<ED>): Promise<ED["userRelation"]["OpSchema"][]>;
diff --git a/src/AspectDict.ts b/src/AspectDict.ts
index 0d03b9c..1d04efa 100644
--- a/src/AspectDict.ts
+++ b/src/AspectDict.ts
@@ -3,21 +3,21 @@ import { AmapInstance } from "oak-external-sdk/lib/service/amap/Amap";
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { AsyncContext } from "oak-domain/lib/store/AsyncRowStore";
 
-export type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = {
+export type AspectDict<ED extends EntityDict & BaseEntityDict> = {
     operate: <T extends keyof ED, OP extends OperateOption>(
         params: {
             entity: T;
             operation: ED[T]['Operation'] | ED[T]['Operation'][];
             option?: OP;
         },
-        context: Cxt
+        context: AsyncContext<ED>
     ) => Promise<OperationResult<ED>[] | OperationResult<ED>>;
     select: <
         T extends keyof ED,
         OP extends SelectOption
     >(
         params: { entity: T; selection: ED[T]['Selection']; option?: OP; getCount?: true },
-        context: Cxt
+        context: AsyncContext<ED>
     ) => Promise<{
         data: Record<string, any>;
         total?: number;
@@ -28,14 +28,14 @@ export type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt extends
             aggregation: ED[T]['Aggregation'];
             option?: OP;
         },
-        context: Cxt
+        context: AsyncContext<ED>
     ) => Promise<AggregationResult<ED[T]['Schema']>>;
     count: <
         T extends keyof ED,
         OP extends SelectOption
     >(
         params: { entity: T; selection: Pick<ED[T]['Selection'], 'filter'>; option?: OP },
-        context: Cxt
+        context: AsyncContext<ED>
     ) => Promise<number>;
     fetchRows: <OP extends SelectOption>(
         params: Array<{
@@ -43,7 +43,7 @@ export type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt extends
             selection: ED[keyof ED]['Selection'];
             option?: OP;
         }>,
-        context: Cxt
+        context: AsyncContext<ED>
     ) => Promise<void>;
     amap: <
         T extends
@@ -61,14 +61,14 @@ export type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt extends
         namespace: string | string[];
         locale: string;
     }) => Promise<any>;
-    importEntity: (params: FormData, context: Cxt) => Promise<void | ArrayBuffer>;
+    importEntity: (params: FormData, context: AsyncContext<ED>) => Promise<void | ArrayBuffer>;
     exportEntity: <T extends keyof ED>(params: {
         entity: T;
         id: string;
         filter?: ED[T]['Selection']['filter'];
         properties?: Record<string, any>;
-    }, context: Cxt) => Promise<ArrayBuffer>;
-    getImportationTemplate: (params: { id: string }, context: Cxt) => Promise<ArrayBuffer>;
+    }, context: AsyncContext<ED>) => Promise<ArrayBuffer>;
+    getImportationTemplate: (params: { id: string }, context: AsyncContext<ED>) => Promise<ArrayBuffer>;
     searchPoi: (options: {
         value: string;
         areaCode?: string;
@@ -78,6 +78,8 @@ export type CommonAspectDict<ED extends EntityDict & BaseEntityDict, Cxt extends
     }) => Promise<{ id: string; areaId: string; poiName: string; detail: string; coordinate: [number, number] }[]>;
     loadRelations: (params: {
         entities: (keyof ED)[],
-    }, context: Cxt) => Promise<ED['userRelation']['OpSchema'][]>;
+    }, context: AsyncContext<ED>) => Promise<ED['userRelation']['OpSchema'][]>;
     crossBridge: (params: { url: string }) => Promise<ReadableStream<Uint8Array>>;
 };
+
+export default AspectDict;
\ No newline at end of file
diff --git a/src/crud.ts b/src/crud.ts
index aea18ad..086a0a2 100644
--- a/src/crud.ts
+++ b/src/crud.ts
@@ -14,7 +14,6 @@ import { assert } from 'oak-domain/lib/utils/assert';
 export async function operate<
     ED extends BaseEntityDict & EntityDict,
     T extends keyof ED,
-    Cxt extends AsyncContext<ED>,
     OP extends OperateOption
 >(
     params: {
@@ -22,7 +21,7 @@ export async function operate<
         operation: ED[T]['Operation'] | ED[T]['Operation'][];
         option?: OP;
     },
-    context: Cxt
+    context: AsyncContext<ED>
 ) {
     const { entity, operation, option } = params;
     /* const userId = context.getCurrentUserId();
@@ -124,7 +123,6 @@ function buildResultTree<ED extends BaseEntityDict & EntityDict, T extends keyof
 export async function select<
     ED extends BaseEntityDict & EntityDict,
     T extends keyof ED,
-    Cxt extends AsyncContext<ED>,
     OP extends SelectOption
 >(
     params: {
@@ -134,7 +132,7 @@ export async function select<
         getCount?: true;
         maxCount?: number;
     },
-    context: Cxt
+    context: AsyncContext<ED>
 ) {
     const { entity, selection, option } = params;
     let selection2 = selection;
@@ -151,28 +149,26 @@ export async function select<
 export async function aggregate<
     ED extends BaseEntityDict & EntityDict,
     T extends keyof ED,
-    Cxt extends AsyncContext<ED>,
     OP extends SelectOption
 >(params: {
     entity: T,
     aggregation: ED[T]['Aggregation'],
     option?: OP,
-}, context: Cxt) {
+}, context: AsyncContext<ED>) {
     const { entity, aggregation, option } = params;
     return context.aggregate(entity, aggregation, option || {});
 }
 
 export async function fetchRows<
     ED extends EntityDict & BaseEntityDict,
-    OP extends SelectOption,
-    Cxt extends AsyncContext<ED>,
+    OP extends SelectOption
     >(
         params: Array<{
             entity: keyof ED;
             selection: ED[keyof ED]['Selection'];
             option?: OP;
         }>,
-        context: Cxt
+        context: AsyncContext<ED>
     ) {
     await Promise.all(
         params.map((ele) =>
@@ -188,7 +184,6 @@ export async function fetchRows<
 export async function count<
     ED extends EntityDict & BaseEntityDict,
     T extends keyof ED,
-    Cxt extends AsyncContext<ED>,
     OP extends SelectOption
 >(
     params: {
@@ -196,7 +191,7 @@ export async function count<
         selection: Pick<ED[T]['Selection'], 'filter'>;
         option?: OP;
     },
-    context: Cxt
+    context: AsyncContext<ED>
 ) {
     const { entity, selection, option } = params;
     const { filter } = selection;
diff --git a/src/relation.ts b/src/relation.ts
index ccf5673..a21b8ab 100644
--- a/src/relation.ts
+++ b/src/relation.ts
@@ -11,11 +11,10 @@ import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
 import { omit } from 'oak-domain/lib/utils/lodash';
 
 export async function loadRelations<
-    ED extends BaseEntityDict & EntityDict,
-    Cxt extends AsyncContext<ED>
+    ED extends BaseEntityDict & EntityDict
 >(params: {
     entities: (keyof ED)[],
-}, context: Cxt) {
+}, context: AsyncContext<ED>) {
     const { entities } = params;
     const userId = context.getCurrentUserId();
     if (!userId) {