export count

lib/AspectDict.d.ts

@@ -15,6 +15,11 @@ export declare type CommonAspectDict<ED extends EntityDict, Cxt extends Context<
         data: SelectRowShape<ED[T]['Schema'], S['data']>[];
         count?: number;
     }>;
+    count: <T extends keyof ED, S extends ED[T]['Selection'], OP extends SelectOption>(params: {
+        entity: T;
+        selection: S;
+        option?: OP;
+    }, context: Cxt) => Promise<number>;
     fetchRows: <OP extends SelectOption>(params: Array<{
         entity: keyof ED;
         selection: ED[keyof ED]['Selection'];

lib/crud.d.ts

@@ -20,3 +20,8 @@ export declare function fetchRows<ED extends EntityDict, OP extends SelectOption
     selection: ED[keyof ED]['Selection'];
     option?: OP;
 }>, context: Cxt): Promise<void>;
+export declare function count<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>, S extends ED[T]['Selection'], OP extends SelectOption>(params: {
+    entity: T;
+    selection: S;
+    option?: OP;
+}, context: Cxt): Promise<number>;

lib/crud.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchRows = exports.select = exports.operate = void 0;
+exports.count = exports.fetchRows = exports.select = exports.operate = void 0;
 const types_1 = require("oak-domain/lib/types");
 async function operate(params, context) {
     const { entity, operation, option } = params;
@@ -37,9 +37,16 @@ async function select(params, context) {
 }
 exports.select = select;
 async function fetchRows(params, context) {
-    await Promise.all(params.map(ele => context.rowStore.select(ele.entity, ele.selection, context, ele.option || {})));
+    await Promise.all(params.map((ele) => context.rowStore.select(ele.entity, ele.selection, context, ele.option || {})));
 }
 exports.fetchRows = fetchRows;
+async function count(params, context) {
+    const { entity, selection, option } = params;
+    const { filter } = selection;
+    const count = await context.rowStore.count(entity, Object.assign({}, { filter }), context, option || {});
+    return count;
+}
+exports.count = count;
 /*
 export type AspectDict<ED extends EntityDict> = {
     operation: <T extends keyof ED>(options: { entity: T, operation: ED[T]['Operation'], params?: OperateParams }, context: Context<ED>) => Promise<OperationResult>;

lib/index.d.ts

@@ -1,9 +1,10 @@
-import { operate, select, fetchRows } from './crud';
+import { operate, select, fetchRows, count } from './crud';
 import { amap } from './amap';
 import { getTranslations } from './locales';
 declare const aspectDict: {
     operate: typeof operate;
     select: typeof select;
+    count: typeof count;
     fetchRows: typeof fetchRows;
     amap: typeof amap;
     getTranslations: typeof getTranslations;

lib/index.js

@@ -7,6 +7,7 @@ const locales_1 = require("./locales");
 const aspectDict = {
     operate: crud_1.operate,
     select: crud_1.select,
+    count: crud_1.count,
     fetchRows: crud_1.fetchRows,
     amap: amap_1.amap,
     getTranslations: locales_1.getTranslations,

src/AspectDict.ts

@@ -2,13 +2,49 @@ import { Context, EntityDict, OperateOption, SelectOption, OperationResult, Sele
 import { AmapInstance } from "oak-external-sdk";
 
 export type CommonAspectDict<ED extends EntityDict, Cxt extends Context<ED>> = {
-    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>>,
+    operate: <T extends keyof ED, OP extends OperateOption>(
-    select: <T extends keyof ED, S extends ED[T]['Selection'], OP extends SelectOption>(params: { entity: T, selection: S, option?: OP, getCount?: true }, context: Cxt) => Promise<{
+        params: {
-        data: SelectRowShape<ED[T]['Schema'], S['data']>[],
+            entity: T;
+            operation: ED[T]['Operation'] | ED[T]['Operation'][];
+            option?: OP;
+        },
+        context: Cxt
+    ) => Promise<OperationResult<ED>[] | OperationResult<ED>>;
+    select: <
+        T extends keyof ED,
+        S extends ED[T]['Selection'],
+        OP extends SelectOption
+    >(
+        params: { entity: T; selection: S; option?: OP; getCount?: true },
+        context: Cxt
+    ) => Promise<{
+        data: SelectRowShape<ED[T]['Schema'], S['data']>[];
         count?: number;
+    }>;
+    count: <
+        T extends keyof ED,
+        S extends ED[T]['Selection'],
+        OP extends SelectOption
+    >(
+        params: { entity: T; selection: S; option?: OP },
+        context: Cxt
+    ) => Promise<number>;
+    fetchRows: <OP extends SelectOption>(
+        params: Array<{
+            entity: keyof ED;
+            selection: ED[keyof ED]['Selection'];
+            option?: OP;
         }>,
-    fetchRows: <OP extends SelectOption>(params: Array<{ entity: keyof ED, selection: ED[keyof ED]['Selection'], option?: OP }>, context: Cxt) => Promise<void>;
+        context: Cxt
-    amap: <T extends 'getDrivingPath' | 'regeo' | 'ipLoc' | 'getDistrict' | 'geocode'>(params: {
+    ) => Promise<void>;
+    amap: <
+        T extends
+            | 'getDrivingPath'
+            | 'regeo'
+            | 'ipLoc'
+            | 'getDistrict'
+            | 'geocode'
+    >(params: {
         key: string;
         method: T;
         data: Parameters<AmapInstance[T]>[0];

src/crud.ts

@@ -1,8 +1,26 @@
-import { OperateOption, EntityDict, Context, SelectOption, SelectRowShape, OakUnloggedInException } from 'oak-domain/lib/types';
+import {
+    OperateOption,
+    EntityDict,
+    Context,
+    SelectOption,
+    SelectRowShape,
+    OakUnloggedInException,
+} from 'oak-domain/lib/types';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 
-export async function operate<ED extends BaseEntityDict & EntityDict, T extends keyof ED, Cxt extends Context<ED>, OP extends OperateOption>(
+export async function operate<
-    params: { entity: T, operation: ED[T]['Operation'] | ED[T]['Operation'][], option?: OP }, context: Cxt) {
+    ED extends BaseEntityDict & EntityDict,
+    T extends keyof ED,
+    Cxt extends Context<ED>,
+    OP extends OperateOption
+>(
+    params: {
+        entity: T;
+        operation: ED[T]['Operation'] | ED[T]['Operation'][];
+        option?: OP;
+    },
+    context: Cxt
+) {
     const { entity, operation, option } = params;
     const userId = await context.getCurrentUserId();
     if (!userId) {
@@ -13,27 +31,61 @@ export async function operate<ED extends BaseEntityDict & EntityDict, T extends
     if (operation instanceof Array) {
         const result = [];
         for (const oper of operation) {
-            const r = await context.rowStore.operate(entity, oper, context, option || {});
+            const r = await context.rowStore.operate(
+                entity,
+                oper,
+                context,
+                option || {}
+            );
             result.push(r);
         }
         return result;
     }
-    return await context.rowStore.operate(entity, operation, context, option || {});
+    return await context.rowStore.operate(
+        entity,
+        operation,
+        context,
+        option || {}
+    );
 }
 
-export async function select<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>, S extends ED[T]['Selection'], OP extends SelectOption>(
+export async function select<
-    params: { entity: T, selection: S, option?: OP, getCount?: true, maxCount?: number }, context: Cxt) {
+    ED extends EntityDict,
+    T extends keyof ED,
+    Cxt extends Context<ED>,
+    S extends ED[T]['Selection'],
+    OP extends SelectOption
+>(
+    params: {
+        entity: T;
+        selection: S;
+        option?: OP;
+        getCount?: true;
+        maxCount?: number;
+    },
+    context: Cxt
+) {
     const { entity, selection, option, getCount, maxCount } = params;
-    const { result: data } = await context.rowStore.select(entity, selection, context, option || {});
+    const { result: data } = await context.rowStore.select(
+        entity,
+        selection,
+        context,
+        option || {}
+    );
     const result = {
         data,
     } as {
-        data: SelectRowShape<ED[T]['Schema'], S['data']>[],
+        data: SelectRowShape<ED[T]['Schema'], S['data']>[];
         count?: number;
     };
     if (getCount) {
         const { filter } = selection;
-        const count = await context.rowStore.count(entity, Object.assign({}, { filter, count: maxCount || 1000 }), context, option || {});
+        const count = await context.rowStore.count(
+            entity,
+            Object.assign({}, { filter, count: maxCount || 1000 }),
+            context,
+            option || {}
+        );
         Object.assign(result, {
             count,
         });
@@ -41,14 +93,55 @@ export async function select<ED extends EntityDict, T extends keyof ED, Cxt exte
     return result;
 }
 
-export async function fetchRows<ED extends EntityDict, OP extends SelectOption, Cxt extends Context<ED>>(params: Array<{ entity: keyof ED, selection: ED[keyof ED]['Selection'], option?: OP }>, context: Cxt) {
+export async function fetchRows<
+    ED extends EntityDict,
+    OP extends SelectOption,
+    Cxt extends Context<ED>
+>(
+    params: Array<{
+        entity: keyof ED;
+        selection: ED[keyof ED]['Selection'];
+        option?: OP;
+    }>,
+    context: Cxt
+) {
     await Promise.all(
-        params.map(
+        params.map((ele) =>
-            ele => context.rowStore.select(ele.entity, ele.selection, context, ele.option || {})
+            context.rowStore.select(
+                ele.entity,
+                ele.selection,
+                context,
+                ele.option || {}
+            )
         )
     );
 }
 
+export async function count<
+    ED extends EntityDict,
+    T extends keyof ED,
+    Cxt extends Context<ED>,
+    S extends ED[T]['Selection'],
+    OP extends SelectOption
+>(
+    params: {
+        entity: T;
+        selection: S;
+        option?: OP;
+    },
+    context: Cxt
+) {
+    const { entity, selection, option } = params;
+    const { filter } = selection;
+    const count = await context.rowStore.count(
+        entity,
+        Object.assign({}, { filter }),
+        context,
+        option || {}
+    );
+    return count;
+}
+
 /* 
 export type AspectDict<ED extends EntityDict> = {
     operation: <T extends keyof ED>(options: { entity: T, operation: ED[T]['Operation'], params?: OperateParams }, context: Context<ED>) => Promise<OperationResult>;

src/index.ts

@@ -1,9 +1,10 @@
-import { operate, select, fetchRows } from './crud';
+import { operate, select, fetchRows, count } from './crud';
 import { amap } from './amap';
 import { getTranslations } from './locales';
 const aspectDict = {
     operate,
     select,
+    count,
     fetchRows,
     amap,
     getTranslations,