forked from agreatfool/SASDN-Database
-
Notifications
You must be signed in to change notification settings - Fork 0
/
index.d.ts
136 lines (123 loc) · 3.33 KB
/
index.d.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
import { BaseEntity, Connection, ConnectionOptions, DatabaseType, ObjectType, Repository } from 'typeorm';
import { ZipkinBase } from 'sasdn-zipkin';
/**
* Declare which Entity in which Connection.
*/
export interface ShardingStrategyInterface {
/**
* Connection Name.
*/
connctionName: string;
/**
* Entity in this connection.
*/
entities: string[];
}
export interface ShardTableMetadataArgs {
/**
* ClassName get by decorate
*/
className: string;
/**
* Table shard count
*/
shardCount: number;
}
export interface DatabaseOptions {
/**
* Database name.
*/
readonly name: string;
/**
* Database type.
*/
readonly type: DatabaseType;
/**
* Need check shard table or not
*/
readonly needCheckShard?: boolean;
/**
* Database cluster.
*/
readonly connectionList: ConnectionOptions[];
/**
* If not define then use default ShardingStrategy(mod)
*/
shardingStrategies?: ShardingStrategyInterface[];
}
/**
* ShardTable Decorate
* @param shardCount shard table count
*/
export declare function ShardTable(shardCount: number): Function;
/**
* Base abstract entity for all entities, used in ActiveRecord patterns.
*/
export declare class BaseOrmEntity extends BaseEntity {
/**
* Gets current entity's Repository.
*/
static getRepository<T extends BaseEntity>(this: ObjectType<T>): Repository<T>;
}
export declare class EntityStorage {
private static _instance;
private _argsMap;
private _filesMap;
static readonly instance: EntityStorage;
/**
* Use global space to storage ShardTableMetadataMap: <className, ShardTableMetadataArgs>
*/
readonly shardTableMetadataStorage: {
[key: string]: ShardTableMetadataArgs;
};
/**
* Use global space to storage ShardTableFileMap: <className, absolutePath>
*/
readonly shardTableFileStorage: {
[key: string]: string;
};
}
export declare class DatabaseFactory {
private static _instance;
private readonly _entityToConnection;
private readonly _shardHashMap;
private readonly _classMap;
static readonly instance: DatabaseFactory;
readonly shardHashMap: {
[key: string]: any;
};
readonly entityToConnection: {
[key: string]: string;
};
updateZipkin(zipkin: ZipkinBase, ctx: object): void;
/**
* Read given path to find ShardTable then copy & rewrite shardTableEntity
* @param {string | Function} entityPath
* @param {Set<string>} classSet
*/
private _checkShardTable(entityPath, classSet);
/**
* Create Database by option
* @param {DatabaseOptions} option DatabaseOptions
* @param {ZipkinBase} zipkin optonal ZipkinProxy import by SASDN-Zipkin
* @param {object} ctx optional koa or grpc context
* @param {string} outputPath which path to create ConnectionMap.json
*/
initialize(option: DatabaseOptions, zipkin?: ZipkinBase, ctx?: object, outputPath?: string): Promise<Connection[]>;
/**
* Return Connection by Entity
* @param {BaseOrmEntity} entity
*/
getConnection<T extends BaseEntity>(entity: ObjectType<T>): Connection;
/**
* Get Entity by given className & shardKey
* @param {string | Function} entity
* @param {string | number} shardKey
*/
getEntity(entity: string | Function, shardKey?: string | number): any;
/**
* Close all connections
* @returns {Promise<void>}
*/
closeAllConnections(): Promise<void>;
}