Oak-Team
/
oak-common-aspect
13
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

export count

This commit is contained in:
Wang Kejun 2022-09-22 14:54:27 +08:00
parent 288163f6f3
commit 9179480993
8 changed files with 172 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/AspectDict.d.ts vendored
View File

@ -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'];

5
lib/crud.d.ts vendored
View File

@ -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>;

11
lib/crud.js
View File

@ -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>;

3
lib/index.d.ts vendored
View File

@ -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;

1
lib/index.js
View File

@ -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,

48
src/AspectDict.ts
View File

@ -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>>,
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']>[],
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>>;
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;
}>,
fetchRows: <OP extends SelectOption>(params: Array<{ entity: keyof ED, selection: ED[keyof ED]['Selection'], option?: OP }>, context: Cxt) => Promise<void>;
amap: <T extends 'getDrivingPath' | 'regeo' | 'ipLoc' | 'getDistrict' | 'geocode'>(params: {
}>;
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;
}>,
context: Cxt
) => Promise<void>;
amap: <
T extends
| 'getDrivingPath'
| 'regeo'
| 'ipLoc'
| 'getDistrict'
| 'geocode'
>(params: {
key: string;
method: T;
data: Parameters<AmapInstance[T]>[0];

119
src/crud.ts
View File

@ -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>(
params: { entity: T, operation: ED[T]['Operation'] | ED[T]['Operation'][], option?: OP }, context: Cxt) {
export async function operate<
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>(
params: { entity: T, selection: S, option?: OP, getCount?: true, maxCount?: number }, context: Cxt) {
export async function select<
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(
ele => context.rowStore.select(ele.entity, ele.selection, context, ele.option || {})
params.map((ele) =>
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>;

3
src/index.ts
View File

@ -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,