Oak-Team
/
oak-domain
13
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 33 Wiki Activity

修正了importation和exportation的定义

This commit is contained in:
Xu Chang 2023-01-08 16:19:51 +08:00
parent 83bb033359
commit 98bd993d02
14 changed files with 234 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
lib/base-app-domain/Modi/Schema.d.ts vendored
View File

@ -2,7 +2,7 @@ import { String } from "../../types/DataType";
import { Q_DateValue, Q_StringValue, Q_EnumValue, NodeId, MakeFilter, ExprOp, ExpressionKey } from "../../types/Demand"; import { Q_DateValue, Q_StringValue, Q_EnumValue, NodeId, MakeFilter, ExprOp, ExpressionKey } from "../../types/Demand";
import { OneOf } from "../../types/Polyfill"; import { OneOf } from "../../types/Polyfill";
import * as SubQuery from "../_SubQuery"; import * as SubQuery from "../_SubQuery";
import { FormCreateData, FormUpdateData, DeduceAggregation, Operation as OakOperation, MakeAction as OakMakeAction, EntityShape } from "../../types/Entity"; import { FormCreateData, FormUpdateData, DeduceAggregation, Operation as OakOperation, MakeAction as OakMakeAction, EntityShape, AggregationResult } from "../../types/Entity";
import { Action, ParticularAction, IState } from "./Action"; import { Action, ParticularAction, IState } from "./Action";
import * as ModiEntity from "../ModiEntity/Schema"; import * as ModiEntity from "../ModiEntity/Schema";
import * as OperEntity from "../OperEntity/Schema"; import * as OperEntity from "../OperEntity/Schema";
@ -27,7 +27,9 @@ export declare type Schema = EntityShape & {
extra?: Object | null; extra?: Object | null;
iState?: IState | null; iState?: IState | null;
modiEntity$modi?: Array<ModiEntity.Schema>; modiEntity$modi?: Array<ModiEntity.Schema>;
modiEntity$modi$$aggr?: AggregationResult<ModiEntity.Schema>;
operEntity$entity?: Array<OperEntity.Schema>; operEntity$entity?: Array<OperEntity.Schema>;
operEntity$entity$$aggr?: AggregationResult<OperEntity.Schema>;
} & { } & {
[A in ExpressionKey]?: any; [A in ExpressionKey]?: any;
}; };
@ -64,29 +66,13 @@ export declare type Projection = {
modiEntity$modi?: ModiEntity.Selection & { modiEntity$modi?: ModiEntity.Selection & {
$entity: "modiEntity"; $entity: "modiEntity";
}; };
modiEntity$modi$$aggr?: ModiEntity.Aggregation & {
$entity: "modiEntity";
};
operEntity$entity?: OperEntity.Selection & { operEntity$entity?: OperEntity.Selection & {
$entity: "operEntity"; $entity: "operEntity";
}; };
} & Partial<ExprOp<OpAttr | string>>; operEntity$entity$$aggr?: OperEntity.Aggregation & {
export declare type ExportProjection = {
"#id"?: NodeId;
[k: string]: any;
id?: string;
$$createAt$$?: string;
$$updateAt$$?: string;
$$seq$$?: string;
targetEntity?: string;
entity?: string;
entityId?: string;
action?: string;
data?: string;
filter?: string;
extra?: string;
iState?: string;
modiEntity$modi?: ModiEntity.Exportation & {
$entity: "modiEntity";
};
operEntity$entity?: OperEntity.Exportation & {
$entity: "operEntity"; $entity: "operEntity";
}; };
} & Partial<ExprOp<OpAttr | string>>; } & Partial<ExprOp<OpAttr | string>>;
@ -122,7 +108,6 @@ export declare type Sorter = SortNode[];
export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">; export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">;
export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">; export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">;
export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">; export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">;
export declare type Exportation = OakOperation<"export", ExportProjection, Filter, Sorter>;
export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "entity" | "entityId">> & ({ export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "entity" | "entityId">> & ({
entity?: string; entity?: string;
entityId?: string; entityId?: string;

14
lib/base-app-domain/ModiEntity/Schema.d.ts vendored
View File

@ -46,19 +46,6 @@ export declare type Projection = {
entityId?: number; entityId?: number;
user?: User.Projection; user?: User.Projection;
} & Partial<ExprOp<OpAttr | string>>; } & Partial<ExprOp<OpAttr | string>>;
export declare type ExportProjection = {
"#id"?: NodeId;
[k: string]: any;
id?: string;
$$createAt$$?: string;
$$updateAt$$?: string;
$$seq$$?: string;
modiId?: string;
modi?: Modi.ExportProjection;
entity?: string;
entityId?: string;
user?: User.ExportProjection;
} & Partial<ExprOp<OpAttr | string>>;
declare type ModiEntityIdProjection = OneOf<{ declare type ModiEntityIdProjection = OneOf<{
id: number; id: number;
}>; }>;
@ -97,7 +84,6 @@ export declare type Sorter = SortNode[];
export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">; export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">;
export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">; export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">;
export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">; export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">;
export declare type Exportation = OakOperation<"export", ExportProjection, Filter, Sorter>;
export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "entity" | "entityId" | "modiId">> & (({ export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "entity" | "entityId" | "modiId">> & (({
modiId?: never; modiId?: never;
modi: Modi.CreateSingleOperation; modi: Modi.CreateSingleOperation;

20
lib/base-app-domain/Oper/Schema.d.ts vendored
View File

@ -2,7 +2,7 @@ import { String, ForeignKey } from "../../types/DataType";
import { Q_DateValue, Q_StringValue, NodeId, MakeFilter, ExprOp, ExpressionKey } from "../../types/Demand"; import { Q_DateValue, Q_StringValue, NodeId, MakeFilter, ExprOp, ExpressionKey } from "../../types/Demand";
import { OneOf } from "../../types/Polyfill"; import { OneOf } from "../../types/Polyfill";
import * as SubQuery from "../_SubQuery"; import * as SubQuery from "../_SubQuery";
import { FormCreateData, FormUpdateData, DeduceAggregation, Operation as OakOperation, MakeAction as OakMakeAction, EntityShape } from "../../types/Entity"; import { FormCreateData, FormUpdateData, DeduceAggregation, Operation as OakOperation, MakeAction as OakMakeAction, EntityShape, AggregationResult } from "../../types/Entity";
import { AppendOnlyAction } from "../../actions/action"; import { AppendOnlyAction } from "../../actions/action";
import * as User from "../User/Schema"; import * as User from "../User/Schema";
import * as OperEntity from "../OperEntity/Schema"; import * as OperEntity from "../OperEntity/Schema";
@ -22,6 +22,7 @@ export declare type Schema = EntityShape & {
operatorId?: ForeignKey<"user"> | null; operatorId?: ForeignKey<"user"> | null;
operator?: User.Schema | null; operator?: User.Schema | null;
operEntity$oper?: Array<OperEntity.Schema>; operEntity$oper?: Array<OperEntity.Schema>;
operEntity$oper$$aggr?: AggregationResult<OperEntity.Schema>;
} & { } & {
[A in ExpressionKey]?: any; [A in ExpressionKey]?: any;
}; };
@ -54,21 +55,7 @@ export declare type Projection = {
operEntity$oper?: OperEntity.Selection & { operEntity$oper?: OperEntity.Selection & {
$entity: "operEntity"; $entity: "operEntity";
}; };
} & Partial<ExprOp<OpAttr | string>>; operEntity$oper$$aggr?: OperEntity.Aggregation & {
export declare type ExportProjection = {
"#id"?: NodeId;
[k: string]: any;
id?: string;
$$createAt$$?: string;
$$updateAt$$?: string;
$$seq$$?: string;
action?: string;
data?: string;
filter?: string;
extra?: string;
operatorId?: string;
operator?: User.ExportProjection;
operEntity$oper?: OperEntity.Exportation & {
$entity: "operEntity"; $entity: "operEntity";
}; };
} & Partial<ExprOp<OpAttr | string>>; } & Partial<ExprOp<OpAttr | string>>;
@ -103,7 +90,6 @@ export declare type Sorter = SortNode[];
export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">; export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">;
export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">; export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">;
export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">; export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">;
export declare type Exportation = OakOperation<"export", ExportProjection, Filter, Sorter>;
export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "operatorId">> & (({ export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "operatorId">> & (({
operatorId?: never; operatorId?: never;
operator?: User.CreateSingleOperation; operator?: User.CreateSingleOperation;

15
lib/base-app-domain/OperEntity/Schema.d.ts vendored
View File

@ -50,20 +50,6 @@ export declare type Projection = {
modi?: Modi.Projection; modi?: Modi.Projection;
user?: User.Projection; user?: User.Projection;
} & Partial<ExprOp<OpAttr | string>>; } & Partial<ExprOp<OpAttr | string>>;
export declare type ExportProjection = {
"#id"?: NodeId;
[k: string]: any;
id?: string;
$$createAt$$?: string;
$$updateAt$$?: string;
$$seq$$?: string;
operId?: string;
oper?: Oper.ExportProjection;
entity?: string;
entityId?: string;
modi?: Modi.ExportProjection;
user?: User.ExportProjection;
} & Partial<ExprOp<OpAttr | string>>;
declare type OperEntityIdProjection = OneOf<{ declare type OperEntityIdProjection = OneOf<{
id: number; id: number;
}>; }>;
@ -107,7 +93,6 @@ export declare type Sorter = SortNode[];
export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">; export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">;
export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">; export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">;
export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">; export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">;
export declare type Exportation = OakOperation<"export", ExportProjection, Filter, Sorter>;
export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "entity" | "entityId" | "operId">> & (({ export declare type CreateOperationData = FormCreateData<Omit<OpSchema, "entity" | "entityId" | "operId">> & (({
operId?: never; operId?: never;
oper: Oper.CreateSingleOperation; oper: Oper.CreateSingleOperation;

31
lib/base-app-domain/User/Schema.d.ts vendored
View File

@ -2,7 +2,7 @@ import { String, Text } from "../../types/DataType";
import { Q_DateValue, Q_StringValue, NodeId, MakeFilter, ExprOp, ExpressionKey } from "../../types/Demand"; import { Q_DateValue, Q_StringValue, NodeId, MakeFilter, ExprOp, ExpressionKey } from "../../types/Demand";
import { OneOf } from "../../types/Polyfill"; import { OneOf } from "../../types/Polyfill";
import * as SubQuery from "../_SubQuery"; import * as SubQuery from "../_SubQuery";
import { FormCreateData, FormUpdateData, DeduceAggregation, Operation as OakOperation, MakeAction as OakMakeAction, EntityShape } from "../../types/Entity"; import { FormCreateData, FormUpdateData, DeduceAggregation, Operation as OakOperation, MakeAction as OakMakeAction, EntityShape, AggregationResult } from "../../types/Entity";
import { GenericAction, RelationAction } from "../../actions/action"; import { GenericAction, RelationAction } from "../../actions/action";
import * as Oper from "../Oper/Schema"; import * as Oper from "../Oper/Schema";
import * as OperEntity from "../OperEntity/Schema"; import * as OperEntity from "../OperEntity/Schema";
@ -18,8 +18,11 @@ export declare type Schema = EntityShape & {
nickname?: String<64> | null; nickname?: String<64> | null;
password?: Text | null; password?: Text | null;
oper$operator?: Array<Oper.Schema>; oper$operator?: Array<Oper.Schema>;
oper$operator$$aggr?: AggregationResult<Oper.Schema>;
operEntity$entity?: Array<OperEntity.Schema>; operEntity$entity?: Array<OperEntity.Schema>;
operEntity$entity$$aggr?: AggregationResult<OperEntity.Schema>;
modiEntity$entity?: Array<ModiEntity.Schema>; modiEntity$entity?: Array<ModiEntity.Schema>;
modiEntity$entity$$aggr?: AggregationResult<ModiEntity.Schema>;
} & { } & {
[A in ExpressionKey]?: any; [A in ExpressionKey]?: any;
}; };
@ -46,30 +49,19 @@ export declare type Projection = {
oper$operator?: Oper.Selection & { oper$operator?: Oper.Selection & {
$entity: "oper"; $entity: "oper";
}; };
oper$operator$$aggr?: Oper.Aggregation & {
$entity: "oper";
};
operEntity$entity?: OperEntity.Selection & { operEntity$entity?: OperEntity.Selection & {
$entity: "operEntity"; $entity: "operEntity";
}; };
operEntity$entity$$aggr?: OperEntity.Aggregation & {
$entity: "operEntity";
};
modiEntity$entity?: ModiEntity.Selection & { modiEntity$entity?: ModiEntity.Selection & {
$entity: "modiEntity"; $entity: "modiEntity";
}; };
} & Partial<ExprOp<OpAttr | string>>; modiEntity$entity$$aggr?: ModiEntity.Aggregation & {
export declare type ExportProjection = {
"#id"?: NodeId;
[k: string]: any;
id?: string;
$$createAt$$?: string;
$$updateAt$$?: string;
$$seq$$?: string;
name?: string;
nickname?: string;
password?: string;
oper$operator?: Oper.Exportation & {
$entity: "oper";
};
operEntity$entity?: OperEntity.Exportation & {
$entity: "operEntity";
};
modiEntity$entity?: ModiEntity.Exportation & {
$entity: "modiEntity"; $entity: "modiEntity";
}; };
} & Partial<ExprOp<OpAttr | string>>; } & Partial<ExprOp<OpAttr | string>>;
@ -101,7 +93,6 @@ export declare type Sorter = SortNode[];
export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">; export declare type SelectOperation<P extends Object = Projection> = Omit<OakOperation<"select", P, Filter, Sorter>, "id">;
export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">; export declare type Selection<P extends Object = Projection> = Omit<SelectOperation<P>, "action">;
export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">; export declare type Aggregation = Omit<DeduceAggregation<Schema, Projection, Filter, Sorter>, "id">;
export declare type Exportation = OakOperation<"export", ExportProjection, Filter, Sorter>;
export declare type CreateOperationData = FormCreateData<OpSchema> & { export declare type CreateOperationData = FormCreateData<OpSchema> & {
oper$operator?: OakOperation<"create", Omit<Oper.CreateOperationData, "operator" | "operatorId">[]> | Array<OakOperation<"create", Omit<Oper.CreateOperationData, "operator" | "operatorId">>>; oper$operator?: OakOperation<"create", Omit<Oper.CreateOperationData, "operator" | "operatorId">[]> | Array<OakOperation<"create", Omit<Oper.CreateOperationData, "operator" | "operatorId">>>;
operEntity$entity?: OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">[]> | Array<OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">>>; operEntity$entity?: OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">[]> | Array<OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">>>;

107
lib/compiler/schemalBuilder.js
View File

@ -966,6 +966,8 @@ function constructSchema(statements, entity) {
foreignKeySet[entityName].forEach(function (foreignKey) { foreignKeySet[entityName].forEach(function (foreignKey) {
var identifier = "".concat(entityNameLc, "$").concat(foreignKey); var identifier = "".concat(entityNameLc, "$").concat(foreignKey);
members2.push(factory.createPropertySignature(undefined, identifier, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Schema'), undefined)]))); members2.push(factory.createPropertySignature(undefined, identifier, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Schema'), undefined)])));
var aggrIdentifier = "".concat(entityNameLc, "$").concat(foreignKey, "$$aggr");
members2.push(factory.createPropertySignature(undefined, aggrIdentifier, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(factory.createIdentifier("AggregationResult"), [factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Schema'), undefined)])));
}); });
}; };
for (var entityName in foreignKeySet) { for (var entityName in foreignKeySet) {
@ -1206,7 +1208,10 @@ function constructProjection(statements, entity) {
}); });
if (manyToOneItem) { if (manyToOneItem) {
// 外键投影 // 外键投影
properties.push(["".concat(attrName, "Id"), false, undefined], [name_4, false, factory.createTypeReferenceNode(createForeignRef(entity, text2_4, 'Projection')), factory.createTypeReferenceNode(createForeignRef(entity, text2_4, 'ExportProjection'))]); properties.push(["".concat(attrName, "Id"), false, undefined], [name_4, false, factory.createTypeReferenceNode(createForeignRef(entity, text2_4, 'Projection')) /* , factory.createTypeReferenceNode(
createForeignRef(entity, text2, 'ExportProjection')
) */
]);
if (foreignKeyProperties.hasOwnProperty(text2_4)) { if (foreignKeyProperties.hasOwnProperty(text2_4)) {
foreignKeyProperties[text2_4].push(attrName); foreignKeyProperties[text2_4].push(attrName);
} }
@ -1256,7 +1261,10 @@ function constructProjection(statements, entity) {
ReversePointerRelations[entity].forEach(function (one) { ReversePointerRelations[entity].forEach(function (one) {
var _a; var _a;
var text2 = one === 'Schema' ? entity : one; var text2 = one === 'Schema' ? entity : one;
properties.push([(0, string_1.firstLetterLowerCase)(one), false, factory.createTypeReferenceNode(createForeignRef(entity, one, 'Projection')), factory.createTypeReferenceNode(createForeignRef(entity, one, 'ExportProjection'))]); properties.push([(0, string_1.firstLetterLowerCase)(one), false, factory.createTypeReferenceNode(createForeignRef(entity, one, 'Projection')) /* , factory.createTypeReferenceNode(
createForeignRef(entity, one, 'ExportProjection')
) */
]);
if (foreignKeyProperties.hasOwnProperty(one)) { if (foreignKeyProperties.hasOwnProperty(one)) {
foreignKeyProperties[text2].push('entity'); foreignKeyProperties[text2].push('entity');
} }
@ -1294,15 +1302,31 @@ function constructProjection(statements, entity) {
var entityNameLc = (0, string_1.firstLetterLowerCase)(entityName); var entityNameLc = (0, string_1.firstLetterLowerCase)(entityName);
foreignKeySet[entityName].forEach(function (foreignKey) { foreignKeySet[entityName].forEach(function (foreignKey) {
var identifier = "".concat(entityNameLc, "$").concat(foreignKey); var identifier = "".concat(entityNameLc, "$").concat(foreignKey);
var aggrIdentifier = "".concat(entityNameLc, "$").concat(foreignKey, "$$aggr");
properties.push([identifier, false, properties.push([identifier, false,
factory.createIntersectionTypeNode([ factory.createIntersectionTypeNode([
factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Selection'), undefined), factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Selection'), undefined),
factory.createTypeLiteralNode([ factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier("$entity"), undefined, factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(entityName)))) factory.createPropertySignature(undefined, factory.createIdentifier("$entity"), undefined, factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(entityName))))
]) ])
]), ]) /* ,
factory.createIntersectionTypeNode([ factory.createIntersectionTypeNode([
factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Exportation'), undefined), factory.createTypeReferenceNode(
createForeignRef(entity, entityName, 'Exportation'),
undefined
),
factory.createTypeLiteralNode([
factory.createPropertySignature(
undefined,
factory.createIdentifier("$entity"),
undefined,
factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(entityName)))
)
])
]) */
], [aggrIdentifier, false,
factory.createIntersectionTypeNode([
factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Aggregation'), undefined),
factory.createTypeLiteralNode([ factory.createTypeLiteralNode([
factory.createPropertySignature(undefined, factory.createIdentifier("$entity"), undefined, factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(entityName)))) factory.createPropertySignature(undefined, factory.createIdentifier("$entity"), undefined, factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(entityName))))
]) ])
@ -1324,28 +1348,47 @@ function constructProjection(statements, entity) {
factory.createTypeReferenceNode(factory.createIdentifier('OpAttr')) factory.createTypeReferenceNode(factory.createIdentifier('OpAttr'))
]) ])
]); ]);
var MetaPropertySignaturs = [ var MetaPropertySignatures = [
factory.createPropertySignature(undefined, factory.createStringLiteral("#id"), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode('NodeId')) factory.createPropertySignature(undefined, factory.createStringLiteral("#id"), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode('NodeId'))
]; ];
if (process.env.COMPLING_AS_LIB) { if (process.env.COMPLING_AS_LIB) {
MetaPropertySignaturs.push(factory.createIndexSignature(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, undefined, factory.createIdentifier("k"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), undefined)], factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword))); MetaPropertySignatures.push(factory.createIndexSignature(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, undefined, factory.createIdentifier("k"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), undefined)], factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)));
} }
// Projection，正常查询的投影 // Projection，正常查询的投影
statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Projection"), undefined, factory.createIntersectionTypeNode([ statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Projection"), undefined, factory.createIntersectionTypeNode([
factory.createTypeLiteralNode(MetaPropertySignaturs.concat(properties.map(function (_a) { factory.createTypeLiteralNode(MetaPropertySignatures.concat(properties.map(function (_a) {
var _b = tslib_1.__read(_a, 3), n = _b[0], q = _b[1], v = _b[2]; var _b = tslib_1.__read(_a, 3), n = _b[0], q = _b[1], v = _b[2];
return factory.createPropertySignature(undefined, n, q ? undefined : factory.createToken(ts.SyntaxKind.QuestionToken), v || factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)); return factory.createPropertySignature(undefined, n, q ? undefined : factory.createToken(ts.SyntaxKind.QuestionToken), v || factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword));
}))), }))),
exprNode, exprNode,
]))); ])));
// ExportProjection，下载查询的投影 // ExportProjection，下载查询的投影
statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("ExportProjection"), undefined, factory.createIntersectionTypeNode([ // 已经废弃。By Xc 2023.01.08
factory.createTypeLiteralNode(MetaPropertySignaturs.concat(properties.map(function (_a) { /* statements.push(
var _b = tslib_1.__read(_a, 4), n = _b[0], q = _b[1], v = _b[2], v2 = _b[3]; factory.createTypeAliasDeclaration(
return factory.createPropertySignature(undefined, n, factory.createToken(ts.SyntaxKind.QuestionToken), v2 || factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)); undefined,
}))), [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
exprNode, factory.createIdentifier("ExportProjection"),
]))); undefined,
factory.createIntersectionTypeNode([
factory.createTypeLiteralNode(
MetaPropertySignaturs.concat(
properties.map(
([n, q, v, v2]) => {
return factory.createPropertySignature(
undefined,
n,
factory.createToken(ts.SyntaxKind.QuestionToken),
v2 || factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
)
}
)
)
),
exprNode,
])
)
); */
// ${Entity}Projection，外键查询的专用投影 // ${Entity}Projection，外键查询的专用投影
for (var foreignKey in foreignKeyProperties) { for (var foreignKey in foreignKeyProperties) {
var identifier = "".concat(foreignKey, "IdProjection"); var identifier = "".concat(foreignKey, "IdProjection");
@ -1731,12 +1774,33 @@ function constructActions(statements, entity) {
factory.createLiteralTypeNode(factory.createStringLiteral("id")) factory.createLiteralTypeNode(factory.createStringLiteral("id"))
]))); ])));
// Exportation // Exportation
statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Exportation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OakOperation"), [ // 已经废弃，by Xc 2023.01.08
factory.createLiteralTypeNode(factory.createStringLiteral("export")), /* statements.push(
factory.createTypeReferenceNode(factory.createIdentifier("ExportProjection"), undefined), factory.createTypeAliasDeclaration(
factory.createTypeReferenceNode(factory.createIdentifier("Filter"), undefined), undefined,
factory.createTypeReferenceNode(factory.createIdentifier("Sorter"), undefined) [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
]))); factory.createIdentifier("Exportation"),
undefined,
factory.createTypeReferenceNode(
factory.createIdentifier("OakOperation"),
[
factory.createLiteralTypeNode(factory.createStringLiteral("export")),
factory.createTypeReferenceNode(
factory.createIdentifier("ExportProjection"),
undefined
),
factory.createTypeReferenceNode(
factory.createIdentifier("Filter"),
undefined
),
factory.createTypeReferenceNode(
factory.createIdentifier("Sorter"),
undefined
)
]
)
)
); */
var _k = ManyToOne, _l = entity, manyToOneSet = _k[_l]; var _k = ManyToOne, _l = entity, manyToOneSet = _k[_l];
var _m = OneToMany, _o = entity, oneToManySet = _m[_o]; var _m = OneToMany, _o = entity, oneToManySet = _m[_o];
var foreignKeySet = {}; var foreignKeySet = {};
@ -2555,6 +2619,7 @@ var initialStatements = function () { return [
factory.createImportSpecifier(false, factory.createIdentifier("Operation"), factory.createIdentifier("OakOperation")), factory.createImportSpecifier(false, factory.createIdentifier("Operation"), factory.createIdentifier("OakOperation")),
factory.createImportSpecifier(false, factory.createIdentifier("MakeAction"), factory.createIdentifier("OakMakeAction")), factory.createImportSpecifier(false, factory.createIdentifier("MakeAction"), factory.createIdentifier("OakMakeAction")),
factory.createImportSpecifier(false, undefined, factory.createIdentifier("EntityShape")), factory.createImportSpecifier(false, undefined, factory.createIdentifier("EntityShape")),
factory.createImportSpecifier(false, undefined, factory.createIdentifier("AggregationResult")),
])), factory.createStringLiteral("".concat((0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(), "Entity")), undefined) ])), factory.createStringLiteral("".concat((0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(), "Entity")), undefined)
]; }; ]; };
function outputSubQuery(outputDir, printer) { function outputSubQuery(outputDir, printer) {

6
lib/store/CascadeStore.d.ts vendored
View File

@ -1,4 +1,4 @@
import { EntityDict, OperateOption, SelectOption, OperationResult, DeduceFilter } from "../types/Entity"; import { EntityDict, OperateOption, SelectOption, OperationResult, DeduceFilter, AggregationResult } from "../types/Entity";
import { EntityDict as BaseEntityDict } from '../base-app-domain'; import { EntityDict as BaseEntityDict } from '../base-app-domain';
import { RowStore } from '../types/RowStore'; import { RowStore } from '../types/RowStore';
import { StorageSchema } from '../types/Storage'; import { StorageSchema } from '../types/Storage';
@ -13,7 +13,9 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
protected abstract updateAbjointRow<T extends keyof ED, OP extends OperateOption, Cxt extends SyncContext<ED>>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): number; protected abstract updateAbjointRow<T extends keyof ED, OP extends OperateOption, Cxt extends SyncContext<ED>>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): number;
protected abstract selectAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>; protected abstract selectAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
protected abstract updateAbjointRowAsync<T extends keyof ED, OP extends OperateOption, Cxt extends AsyncContext<ED>>(entity: T, operation: ED[T]['Create'] | ED[T]['Update'] | ED[T]['Remove'], context: Cxt, option: OP): Promise<number>; protected abstract updateAbjointRowAsync<T extends keyof ED, OP extends OperateOption, Cxt extends AsyncContext<ED>>(entity: T, operation: ED[T]['Create'] | ED[T]['Update'] | ED[T]['Remove'], context: Cxt, option: OP): Promise<number>;
protected destructCascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED> | AsyncContext<ED>, R>(entity: T, projection2: ED[T]['Selection']['data'], context: Cxt, cascadeSelect: <T2 extends keyof ED>(entity2: T2, selection: ED[T2]['Selection'], context: Cxt, op: OP) => R, option: OP): { protected abstract aggregateSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
protected abstract aggregateAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
protected destructCascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, projection2: ED[T]['Selection']['data'], context: Cxt, cascadeSelectFn: <T2 extends keyof ED>(entity2: T2, selection: ED[T2]['Selection'], context: Cxt, op: OP) => Partial<ED[T2]['Schema']>[] | Promise<Partial<ED[T2]['Schema']>[]>, option: OP): {
projection: ED[T]["Selection"]["data"]; projection: ED[T]["Selection"]["data"];
cascadeSelectionFns: ((result: Partial<ED[T]['Schema']>[]) => Promise<void> | void)[]; cascadeSelectionFns: ((result: Partial<ED[T]['Schema']>[]) => Promise<void> | void)[];
}; };

14
lib/store/CascadeStore.js
View File

@ -17,7 +17,7 @@ var CascadeStore = /** @class */ (function (_super) {
function CascadeStore(storageSchema) { function CascadeStore(storageSchema) {
return _super.call(this, storageSchema) || this; return _super.call(this, storageSchema) || this;
} }
CascadeStore.prototype.destructCascadeSelect = function (entity, projection2, context, cascadeSelect, option) { CascadeStore.prototype.destructCascadeSelect = function (entity, projection2, context, cascadeSelectFn, option) {
var _this = this; var _this = this;
var projection = {}; var projection = {};
var cascadeSelectionFns = []; var cascadeSelectionFns = [];
@ -58,7 +58,7 @@ var CascadeStore = /** @class */ (function (_super) {
}); });
} }
}); });
var _e = this_1.destructCascadeSelect(attr, projection2[attr], context, cascadeSelect, option), subProjection = _e.projection, subCascadeSelectionFns = _e.cascadeSelectionFns; var _e = this_1.destructCascadeSelect(attr, projection2[attr], context, cascadeSelectFn, option), subProjection = _e.projection, subCascadeSelectionFns = _e.cascadeSelectionFns;
Object.assign(projection, (_b = {}, Object.assign(projection, (_b = {},
_b[attr] = subProjection, _b[attr] = subProjection,
_b)); _b));
@ -101,7 +101,7 @@ var CascadeStore = /** @class */ (function (_super) {
}); });
}; };
var entityIds = (0, lodash_1.uniq)(result.filter(function (ele) { return ele.entity === attr; }).map(function (ele) { return ele.entityId; })); var entityIds = (0, lodash_1.uniq)(result.filter(function (ele) { return ele.entity === attr; }).map(function (ele) { return ele.entityId; }));
var subRows = cascadeSelect.call(_this, attr, { var subRows = cascadeSelectFn.call(_this, attr, {
data: projection2[attr], data: projection2[attr],
filter: { filter: {
id: { id: {
@ -143,7 +143,7 @@ var CascadeStore = /** @class */ (function (_super) {
} }
}); });
} }
var _f = this_1.destructCascadeSelect(relation, projection2[attr], context, cascadeSelect, option), subProjection = _f.projection, subCascadeSelectionFns = _f.cascadeSelectionFns; var _f = this_1.destructCascadeSelect(relation, projection2[attr], context, cascadeSelectFn, option), subProjection = _f.projection, subCascadeSelectionFns = _f.cascadeSelectionFns;
Object.assign(projection, (_d = {}, Object.assign(projection, (_d = {},
_d[attr] = subProjection, _d[attr] = subProjection,
_d)); _d));
@ -191,7 +191,7 @@ var CascadeStore = /** @class */ (function (_super) {
}); });
}; };
var ids = (0, lodash_1.uniq)(result.filter(function (ele) { return !!(ele["".concat(attr, "Id")]); }).map(function (ele) { return ele["".concat(attr, "Id")]; })); var ids = (0, lodash_1.uniq)(result.filter(function (ele) { return !!(ele["".concat(attr, "Id")]); }).map(function (ele) { return ele["".concat(attr, "Id")]; }));
var subRows = cascadeSelect.call(_this, relation, { var subRows = cascadeSelectFn.call(_this, relation, {
data: projection2[attr], data: projection2[attr],
filter: { filter: {
id: { id: {
@ -225,7 +225,7 @@ var CascadeStore = /** @class */ (function (_super) {
_a)); _a));
}); });
}; };
var subRows = cascadeSelect.call(_this, entity2_1, { var subRows = cascadeSelectFn.call(_this, entity2_1, {
data: subProjection_1, data: subProjection_1,
filter: (0, filter_1.combineFilters)([(_a = {}, filter: (0, filter_1.combineFilters)([(_a = {},
_a[foreignKey_1] = { _a[foreignKey_1] = {
@ -256,7 +256,7 @@ var CascadeStore = /** @class */ (function (_super) {
_a)); _a));
}); });
}; };
var subRows = cascadeSelect.call(_this, entity2_1, { var subRows = cascadeSelectFn.call(_this, entity2_1, {
data: subProjection_1, data: subProjection_1,
filter: (0, filter_1.combineFilters)([{ filter: (0, filter_1.combineFilters)([{
entity: entity, entity: entity,

5
lib/store/relation.js
View File

@ -24,9 +24,10 @@ function judgeRelation(schema, entity, attr) {
return 1; return 1;
} }
if (attr.includes('$')) { if (attr.includes('$')) {
var entity2 = attr.slice(0, attr.indexOf('$')); var firstDelimiter = attr.indexOf('$');
var entity2 = attr.slice(0, firstDelimiter);
(0, assert_1.default)(schema.hasOwnProperty(entity2)); (0, assert_1.default)(schema.hasOwnProperty(entity2));
var foreignKey = attr.slice(attr.indexOf('$') + 1); var foreignKey = attr.slice(firstDelimiter + 1, attr.indexOf('$', firstDelimiter + 1));
var _c = schema, _d = entity2, attributes2 = _c[_d].attributes; var _c = schema, _d = entity2, attributes2 = _c[_d].attributes;
if (foreignKey === 'entity') { if (foreignKey === 'entity') {
// 基于反指对象的反向关联 // 基于反指对象的反向关联

8
lib/types/Entity.d.ts vendored
View File

@ -174,14 +174,14 @@ export declare type Exportation<ED extends EntityDict, T extends keyof ED, K ext
id: string; id: string;
entity: T; entity: T;
projection: ED[T]['Selection']['data']; projection: ED[T]['Selection']['data'];
header: K[]; headers: K[];
fn: (data: ED[T]['Schema']) => Record<K, string | number | boolean | null>; 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> = { export declare type Importation<ED extends EntityDict, T extends keyof ED, K extends string> = {
name: string; name: string;
id: string; id: string;
entity: T; entity: T;
header: K[]; headers: K[];
fn: (data: Record<K, string | number | boolean>) => ED[T]['CreateSingle']['data']; fn: (data: Partial<Record<K, string | number | boolean>>) => ED[T]['CreateSingle']['data'];
}; };
export {}; export {};

115
src/compiler/schemalBuilder.ts
View File

@ -1361,6 +1361,21 @@ function constructSchema(statements: Array<ts.Statement>, entity: string) {
), ),
) )
); );
const aggrIdentifier = `${entityNameLc}$${foreignKey}$$aggr`;
members2.push(
factory.createPropertySignature(
undefined,
aggrIdentifier,
factory.createToken(ts.SyntaxKind.QuestionToken),
factory.createTypeReferenceNode(
factory.createIdentifier("AggregationResult"),
[factory.createTypeReferenceNode(
createForeignRef(entity, entityName, 'Schema'),
undefined
)]
)
)
)
} }
); );
} }
@ -1758,7 +1773,7 @@ function constructFilter(statements: Array<ts.Statement>, entity: string) {
*/ */
function constructProjection(statements: Array<ts.Statement>, entity: string) { function constructProjection(statements: Array<ts.Statement>, entity: string) {
const { schemaAttrs } = Schema[entity]; const { schemaAttrs } = Schema[entity];
const properties: Array<[string | ts.PropertyName, boolean, ts.TypeNode?, ts.TypeNode?]> = [ const properties: Array<[string | ts.PropertyName, boolean, ts.TypeNode?/* , ts.TypeNode? */]> = [
['id', false], ['id', false],
['$$createAt$$', false], ['$$createAt$$', false],
['$$updateAt$$', false], ['$$updateAt$$', false],
@ -1808,9 +1823,9 @@ function constructProjection(statements: Array<ts.Statement>, entity: string) {
[`${attrName}Id`, false, undefined], [`${attrName}Id`, false, undefined],
[name, false, factory.createTypeReferenceNode( [name, false, factory.createTypeReferenceNode(
createForeignRef(entity, text2, 'Projection') createForeignRef(entity, text2, 'Projection')
), factory.createTypeReferenceNode( )/* , factory.createTypeReferenceNode(
createForeignRef(entity, text2, 'ExportProjection') createForeignRef(entity, text2, 'ExportProjection')
)] ) */]
); );
if (foreignKeyProperties.hasOwnProperty(text2)) { if (foreignKeyProperties.hasOwnProperty(text2)) {
foreignKeyProperties[text2].push(attrName); foreignKeyProperties[text2].push(attrName);
@ -1858,9 +1873,9 @@ function constructProjection(statements: Array<ts.Statement>, entity: string) {
properties.push( properties.push(
[firstLetterLowerCase(one), false, factory.createTypeReferenceNode( [firstLetterLowerCase(one), false, factory.createTypeReferenceNode(
createForeignRef(entity, one, 'Projection') createForeignRef(entity, one, 'Projection')
), factory.createTypeReferenceNode( )/* , factory.createTypeReferenceNode(
createForeignRef(entity, one, 'ExportProjection') createForeignRef(entity, one, 'ExportProjection')
)] ) */]
); );
if (foreignKeyProperties.hasOwnProperty(one)) { if (foreignKeyProperties.hasOwnProperty(one)) {
foreignKeyProperties[text2].push('entity'); foreignKeyProperties[text2].push('entity');
@ -1894,6 +1909,7 @@ function constructProjection(statements: Array<ts.Statement>, entity: string) {
foreignKeySet[entityName].forEach( foreignKeySet[entityName].forEach(
(foreignKey) => { (foreignKey) => {
const identifier = `${entityNameLc}$${foreignKey}`; const identifier = `${entityNameLc}$${foreignKey}`;
const aggrIdentifier = `${entityNameLc}$${foreignKey}$$aggr`;
properties.push( properties.push(
[identifier, false, [identifier, false,
factory.createIntersectionTypeNode([ factory.createIntersectionTypeNode([
@ -1909,7 +1925,7 @@ function constructProjection(statements: Array<ts.Statement>, entity: string) {
factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(entityName))) factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(entityName)))
) )
]) ])
]), ])/* ,
factory.createIntersectionTypeNode([ factory.createIntersectionTypeNode([
factory.createTypeReferenceNode( factory.createTypeReferenceNode(
createForeignRef(entity, entityName, 'Exportation'), createForeignRef(entity, entityName, 'Exportation'),
@ -1923,6 +1939,22 @@ function constructProjection(statements: Array<ts.Statement>, entity: string) {
factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(entityName))) factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(entityName)))
) )
]) ])
]) */
],
[aggrIdentifier, false,
factory.createIntersectionTypeNode([
factory.createTypeReferenceNode(
createForeignRef(entity, entityName, 'Aggregation'),
undefined
),
factory.createTypeLiteralNode([
factory.createPropertySignature(
undefined,
factory.createIdentifier("$entity"),
undefined,
factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(entityName)))
)
])
]) ])
] ]
); );
@ -1952,7 +1984,7 @@ function constructProjection(statements: Array<ts.Statement>, entity: string) {
] ]
); );
const MetaPropertySignaturs: ts.TypeElement[] = [ const MetaPropertySignatures: ts.TypeElement[] = [
factory.createPropertySignature( factory.createPropertySignature(
undefined, undefined,
factory.createStringLiteral("#id"), factory.createStringLiteral("#id"),
@ -1963,7 +1995,7 @@ function constructProjection(statements: Array<ts.Statement>, entity: string) {
) )
]; ];
if (process.env.COMPLING_AS_LIB) { if (process.env.COMPLING_AS_LIB) {
MetaPropertySignaturs.push( MetaPropertySignatures.push(
factory.createIndexSignature( factory.createIndexSignature(
undefined, undefined,
undefined, undefined,
@ -1989,7 +2021,7 @@ function constructProjection(statements: Array<ts.Statement>, entity: string) {
undefined, undefined,
factory.createIntersectionTypeNode([ factory.createIntersectionTypeNode([
factory.createTypeLiteralNode( factory.createTypeLiteralNode(
MetaPropertySignaturs.concat( MetaPropertySignatures.concat(
properties.map( properties.map(
([n, q, v]) => { ([n, q, v]) => {
return factory.createPropertySignature( return factory.createPropertySignature(
@ -2007,8 +2039,9 @@ function constructProjection(statements: Array<ts.Statement>, entity: string) {
) )
); );
// ExportProjection，下载查询的投影 // ExportProjection，下载查询的投影
statements.push( // 已经废弃。By Xc 2023.01.08
/* statements.push(
factory.createTypeAliasDeclaration( factory.createTypeAliasDeclaration(
undefined, undefined,
[factory.createModifier(ts.SyntaxKind.ExportKeyword)], [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
@ -2032,7 +2065,7 @@ function constructProjection(statements: Array<ts.Statement>, entity: string) {
exprNode, exprNode,
]) ])
) )
); ); */
// ${Entity}Projection，外键查询的专用投影 // ${Entity}Projection，外键查询的专用投影
for (const foreignKey in foreignKeyProperties) { for (const foreignKey in foreignKeyProperties) {
@ -2838,32 +2871,33 @@ function constructActions(statements: Array<ts.Statement>, entity: string) {
); );
// Exportation // Exportation
statements.push( // 已经废弃，by Xc 2023.01.08
factory.createTypeAliasDeclaration( /* statements.push(
undefined, factory.createTypeAliasDeclaration(
[factory.createModifier(ts.SyntaxKind.ExportKeyword)], undefined,
factory.createIdentifier("Exportation"), [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
undefined, factory.createIdentifier("Exportation"),
factory.createTypeReferenceNode( undefined,
factory.createIdentifier("OakOperation"), factory.createTypeReferenceNode(
[ factory.createIdentifier("OakOperation"),
factory.createLiteralTypeNode(factory.createStringLiteral("export")), [
factory.createTypeReferenceNode( factory.createLiteralTypeNode(factory.createStringLiteral("export")),
factory.createIdentifier("ExportProjection"), factory.createTypeReferenceNode(
undefined factory.createIdentifier("ExportProjection"),
), undefined
factory.createTypeReferenceNode( ),
factory.createIdentifier("Filter"), factory.createTypeReferenceNode(
undefined factory.createIdentifier("Filter"),
), undefined
factory.createTypeReferenceNode( ),
factory.createIdentifier("Sorter"), factory.createTypeReferenceNode(
undefined factory.createIdentifier("Sorter"),
) undefined
] )
) ]
) )
); )
); */
const { [entity]: manyToOneSet } = ManyToOne; const { [entity]: manyToOneSet } = ManyToOne;
const { [entity]: oneToManySet } = OneToMany; const { [entity]: oneToManySet } = OneToMany;
@ -4469,6 +4503,11 @@ const initialStatements = () => [
undefined, undefined,
factory.createIdentifier("EntityShape") factory.createIdentifier("EntityShape")
), ),
factory.createImportSpecifier(
false,
undefined,
factory.createIdentifier("AggregationResult")
),
]) ])
), ),
factory.createStringLiteral(`${TYPE_PATH_IN_OAK_DOMAIN()}Entity`), factory.createStringLiteral(`${TYPE_PATH_IN_OAK_DOMAIN()}Entity`),

36
src/store/CascadeStore.ts
View File

@ -1,7 +1,7 @@
import assert from "assert"; import assert from "assert";
import { import {
EntityDict, EntityDict,
OperateOption, SelectOption, OperationResult, DeduceFilter, CreateAtAttribute, UpdateAtAttribute OperateOption, SelectOption, OperationResult, DeduceFilter, CreateAtAttribute, UpdateAtAttribute, AggregationResult
} from "../types/Entity"; } from "../types/Entity";
import { EntityDict as BaseEntityDict } from '../base-app-domain'; import { EntityDict as BaseEntityDict } from '../base-app-domain';
import { RowStore } from '../types/RowStore'; import { RowStore } from '../types/RowStore';
@ -49,11 +49,23 @@ export abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> exten
context: Cxt, context: Cxt,
option: OP): Promise<number>; option: OP): Promise<number>;
protected destructCascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED> | AsyncContext<ED>, R>( protected abstract aggregateSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(
entity: T,
aggregation: ED[T]['Aggregation'],
context: Cxt,
option: OP): AggregationResult<ED[T]['Schema']>;
protected abstract aggregateAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(
entity: T,
aggregation: ED[T]['Aggregation'],
context: Cxt,
option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
protected destructCascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED> | AsyncContext<ED>>(
entity: T, entity: T,
projection2: ED[T]['Selection']['data'], projection2: ED[T]['Selection']['data'],
context: Cxt, context: Cxt,
cascadeSelect: <T2 extends keyof ED>(entity2: T2, selection: ED[T2]['Selection'], context: Cxt, op: OP) => R, cascadeSelectFn: <T2 extends keyof ED>(entity2: T2, selection: ED[T2]['Selection'], context: Cxt, op: OP) => Partial<ED[T2]['Schema']>[] | Promise<Partial<ED[T2]['Schema']>[]>,
option: OP) { option: OP) {
const projection: ED[T]['Selection']['data'] = {}; const projection: ED[T]['Selection']['data'] = {};
const cascadeSelectionFns: Array<(result: Partial<ED[T]['Schema']>[]) => Promise<void> | void> = []; const cascadeSelectionFns: Array<(result: Partial<ED[T]['Schema']>[]) => Promise<void> | void> = [];
@ -102,7 +114,7 @@ export abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> exten
const { const {
projection: subProjection, projection: subProjection,
cascadeSelectionFns: subCascadeSelectionFns, cascadeSelectionFns: subCascadeSelectionFns,
} = this.destructCascadeSelect(attr, projection2[attr], context, cascadeSelect, option); } = this.destructCascadeSelect(attr, projection2[attr], context, cascadeSelectFn, option);
Object.assign(projection, { Object.assign(projection, {
[attr]: subProjection, [attr]: subProjection,
}); });
@ -159,7 +171,7 @@ export abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> exten
ele => ele.entityId ele => ele.entityId
) as string[]); ) as string[]);
const subRows = cascadeSelect.call(this, attr as any, { const subRows = cascadeSelectFn.call(this, attr as any, {
data: projection2[attr], data: projection2[attr],
filter: { filter: {
id: { id: {
@ -211,7 +223,7 @@ export abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> exten
const { const {
projection: subProjection, projection: subProjection,
cascadeSelectionFns: subCascadeSelectionFns, cascadeSelectionFns: subCascadeSelectionFns,
} = this.destructCascadeSelect(relation, projection2[attr], context, cascadeSelect, option); } = this.destructCascadeSelect(relation, projection2[attr], context, cascadeSelectFn, option);
Object.assign(projection, { Object.assign(projection, {
[attr]: subProjection, [attr]: subProjection,
}); });
@ -273,7 +285,7 @@ export abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> exten
ele => ele[`${attr}Id`] ele => ele[`${attr}Id`]
) as string[]); ) as string[]);
const subRows = cascadeSelect.call(this, relation, { const subRows = cascadeSelectFn.call(this, relation, {
data: projection2[attr], data: projection2[attr],
filter: { filter: {
id: { id: {
@ -317,7 +329,7 @@ export abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> exten
); );
}; };
const subRows = cascadeSelect.call(this, entity2, { const subRows = cascadeSelectFn.call(this, entity2, {
data: subProjection, data: subProjection,
filter: combineFilters([{ filter: combineFilters([{
[foreignKey]: { [foreignKey]: {
@ -358,7 +370,7 @@ export abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> exten
); );
}; };
const subRows = cascadeSelect.call(this, entity2, { const subRows = cascadeSelectFn.call(this, entity2, {
data: subProjection, data: subProjection,
filter: combineFilters([{ filter: combineFilters([{
entity, entity,
@ -557,7 +569,7 @@ export abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> exten
entity, entity,
data: { data: {
[`${attr}Id`]: 1, [`${attr}Id`]: 1,
}, },
filter, filter,
} }
}, },
@ -1375,7 +1387,7 @@ export abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> exten
* @param rows * @param rows
* @param context * @param context
*/ */
private addToResultSelections<T extends keyof ED, Cxt extends AsyncContext<ED>>(entity: T, rows: Partial<ED[T]['Schema']>[], context: Cxt) { private addToResultSelections<T extends keyof ED, Cxt extends AsyncContext<ED>>(entity: T, rows: Partial<ED[T]['Schema']>[], context: Cxt) {
if (this.supportManyToOneJoin()) { if (this.supportManyToOneJoin()) {
const attrsToPick: string[] = []; const attrsToPick: string[] = [];
for (const attr in rows[0]) { for (const attr in rows[0]) {
@ -1453,7 +1465,7 @@ export abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> exten
[entity]: entityBranch, [entity]: entityBranch,
}); });
} }
protected async cascadeSelectAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>( protected async cascadeSelectAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(
entity: T, entity: T,
selection: ED[T]['Selection'], selection: ED[T]['Selection'],

5
src/store/relation.ts
View File

@ -27,9 +27,10 @@ export function judgeRelation<ED extends {
} }
if (attr.includes('$')) { if (attr.includes('$')) {
const entity2 = attr.slice(0, attr.indexOf('$')); const firstDelimiter = attr.indexOf('$');
const entity2 = attr.slice(0, firstDelimiter);
assert (schema.hasOwnProperty(entity2)); assert (schema.hasOwnProperty(entity2));
const foreignKey = attr.slice(attr.indexOf('$') + 1); const foreignKey = attr.slice(firstDelimiter + 1, attr.indexOf('$', firstDelimiter + 1));
const { [entity2]: { attributes: attributes2 } } = schema; const { [entity2]: { attributes: attributes2 } } = schema;
if (foreignKey === 'entity') { if (foreignKey === 'entity') {

10
src/types/Entity.ts
View File

@ -252,14 +252,14 @@ export type Exportation<ED extends EntityDict, T extends keyof ED, K extends str
id: string; id: string;
entity: T; entity: T;
projection: ED[T]['Selection']['data']; projection: ED[T]['Selection']['data'];
header: K[]; headers: K[];
fn: (data: ED[T]['Schema']) => Record<K, string | number | boolean | null>; fn: (data: ED[T]['Schema']) => Partial<Record<K, string | number | boolean | null>>;
}; };
export type Importation<ED extends EntityDict, T extends keyof ED, K extends string> = { export type Importation<ED extends EntityDict, T extends keyof ED, K extends string> = {
name: string; name: string;
id: string; id: string;
entity: T; entity: T;
header: K[]; headers: K[];
fn: (data: Record<K, string | number | boolean>) => ED[T]['CreateSingle']['data']; fn: (data: Partial<Record<K, string | number | boolean>>) => ED[T]['CreateSingle']['data'];
}; };