1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 | import {AnyObject, Callback, Options, PromiseOrVoid} from './common';
|
7 | import {ModelData} from './model';
|
8 | import {
|
9 | Count,
|
10 | PersistedData,
|
11 | PersistedModel,
|
12 | PersistedModelClass,
|
13 | } from './persisted-model';
|
14 | import {Filter, Where} from './query';
|
15 |
|
16 |
|
17 |
|
18 |
|
19 | export enum RelationType {
|
20 | belongsTo = 'belongsTo',
|
21 | hasMany = 'hasMany',
|
22 | hasOne = 'hasOne',
|
23 | hasAndBelongsToMany = 'hasAndBelongsToMany',
|
24 | referencesMany = 'referencesMany',
|
25 | embedsOne = 'embedsOne',
|
26 | embedsMany = 'embedsMany',
|
27 | }
|
28 |
|
29 |
|
30 |
|
31 |
|
32 | export declare class RelationDefinition {
|
33 | name: string;
|
34 | type: RelationType;
|
35 | modelFrom: PersistedModelClass | string;
|
36 | keyFrom: string;
|
37 | modelTo: PersistedModelClass | string;
|
38 | keyTo: string;
|
39 | polymorphic: AnyObject | boolean;
|
40 | modelThrough?: PersistedModelClass | string;
|
41 | keyThrough?: string;
|
42 | multiple: boolean;
|
43 | properties: AnyObject;
|
44 | options: Options;
|
45 | scope: AnyObject;
|
46 | embed?: boolean;
|
47 | methods?: AnyObject<Function>;
|
48 |
|
49 | toJSON(): AnyObject;
|
50 | defineMethod(name: string, fn: Function): Function;
|
51 | applyScope(modelInstance: PersistedData, filter: Filter): void;
|
52 | applyProperties(modelInstance: PersistedData, obj: AnyObject): void;
|
53 | }
|
54 |
|
55 |
|
56 |
|
57 |
|
58 | export declare class Relation<
|
59 | S extends PersistedModel = PersistedModel,
|
60 | T extends PersistedModel = PersistedModel
|
61 | > {
|
62 | constructor(definition: RelationDefinition, modelInstance: S);
|
63 |
|
64 | resetCache(cache: T): void;
|
65 | getCache(): AnyObject<T>;
|
66 | callScopeMethod(methodName: string, ...args: any[]): any;
|
67 | fetch(
|
68 | condOrRefresh: boolean | AnyObject,
|
69 | options?: Options,
|
70 | callback?: Callback<T | T[]>,
|
71 | ): PromiseOrVoid<T | T[]>;
|
72 | }
|
73 |
|
74 | export declare class BelongsTo<
|
75 | S extends PersistedModel = PersistedModel,
|
76 | T extends PersistedModel = PersistedModel
|
77 | > extends Relation<S, T> {
|
78 | create(
|
79 | targetModelData: PersistedData<T>,
|
80 | options?: Options,
|
81 | callback?: Callback<T>,
|
82 | ): PromiseOrVoid<T>;
|
83 |
|
84 | build(targetModelData: PersistedData<T>): T;
|
85 |
|
86 | update(
|
87 | targetModelData: PersistedData<T>,
|
88 | options?: Options,
|
89 | callback?: Callback<boolean>,
|
90 | ): PromiseOrVoid<boolean>;
|
91 |
|
92 | destroy(
|
93 | options?: Options,
|
94 | callback?: Callback<boolean>,
|
95 | ): PromiseOrVoid<boolean>;
|
96 |
|
97 | related(
|
98 | condOrRefresh: boolean | AnyObject,
|
99 | options?: Options,
|
100 | callback?: Callback<T>,
|
101 | ): PromiseOrVoid<T>;
|
102 |
|
103 | get(options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
|
104 | }
|
105 |
|
106 | export declare class HasMany<
|
107 | S extends PersistedModel = PersistedModel,
|
108 | T extends PersistedModel = PersistedModel
|
109 | > extends Relation<S, T> {
|
110 | removeFromCache(id: any): T | null;
|
111 |
|
112 | addToCache(inst: T): void;
|
113 |
|
114 | findById(
|
115 | fkId: any,
|
116 | options?: Options,
|
117 | callback?: Callback<T>,
|
118 | ): PromiseOrVoid<T>;
|
119 |
|
120 | exists(
|
121 | fkId: any,
|
122 | options?: Options,
|
123 | callback?: Callback<boolean>,
|
124 | ): PromiseOrVoid<boolean>;
|
125 |
|
126 | updateById(
|
127 | fkId: any,
|
128 | data: ModelData,
|
129 | options?: Options,
|
130 | callback?: Callback<boolean>,
|
131 | ): PromiseOrVoid<boolean>;
|
132 |
|
133 | destroyById(
|
134 | fkId: any,
|
135 | options?: Options,
|
136 | callback?: Callback<boolean>,
|
137 | ): PromiseOrVoid<boolean>;
|
138 | }
|
139 |
|
140 | export declare class HasManyThrough<
|
141 | S extends PersistedModel = PersistedModel,
|
142 | T extends PersistedModel = PersistedModel
|
143 | > extends Relation<S, T> {
|
144 | findById(
|
145 | fkId: any,
|
146 | options?: Options,
|
147 | callback?: Callback<T>,
|
148 | ): PromiseOrVoid<T>;
|
149 |
|
150 | destroyById(
|
151 | fkId: any,
|
152 | options?: Options,
|
153 | callback?: Callback<boolean>,
|
154 | ): PromiseOrVoid<boolean>;
|
155 |
|
156 | create(
|
157 | data: PersistedData<T>,
|
158 | options?: Options,
|
159 | callback?: Callback<T>,
|
160 | ): PromiseOrVoid<T>;
|
161 |
|
162 | add(
|
163 | acInst: any,
|
164 | data: PersistedData<T>,
|
165 | options?: Options,
|
166 | callback?: Callback<boolean>,
|
167 | ): PromiseOrVoid<boolean>;
|
168 |
|
169 | exists(
|
170 | acInst: any,
|
171 | options?: Options,
|
172 | callback?: Callback<boolean>,
|
173 | ): PromiseOrVoid<boolean>;
|
174 |
|
175 | remove(
|
176 | acInst: any,
|
177 | options?: Options,
|
178 | callback?: Callback<boolean>,
|
179 | ): PromiseOrVoid<boolean>;
|
180 | }
|
181 |
|
182 | export declare class HasOne<
|
183 | S extends PersistedModel = PersistedModel,
|
184 | T extends PersistedModel = PersistedModel
|
185 | > extends Relation<S, T> {
|
186 | create(
|
187 | targetModelData: PersistedData<T>,
|
188 | options?: Options,
|
189 | callback?: Callback<T>,
|
190 | ): PromiseOrVoid<T>;
|
191 |
|
192 | update(
|
193 | targetModelData: PersistedData<T>,
|
194 | options?: Options,
|
195 | callback?: Callback<boolean>,
|
196 | ): PromiseOrVoid<boolean>;
|
197 |
|
198 | destroy(
|
199 | options?: Options,
|
200 | callback?: Callback<boolean>,
|
201 | ): PromiseOrVoid<boolean>;
|
202 |
|
203 | build(targetModelData: PersistedData<T>): T;
|
204 |
|
205 | related(
|
206 | condOrRefresh: any,
|
207 | options?: Options,
|
208 | callback?: Callback<T>,
|
209 | ): PromiseOrVoid<T>;
|
210 |
|
211 | get(options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
|
212 | }
|
213 |
|
214 | export declare class HasAndBelongsToMany<
|
215 | S extends PersistedModel = PersistedModel,
|
216 | T extends PersistedModel = PersistedModel
|
217 | > extends Relation<S, T> {}
|
218 |
|
219 | export declare class ReferencesMany<
|
220 | S extends PersistedModel = PersistedModel,
|
221 | T extends PersistedModel = PersistedModel
|
222 | > extends Relation<S, T> {
|
223 | related(
|
224 | receiver: PersistedModelClass,
|
225 | scopeParams: AnyObject,
|
226 | condOrRefresh: any,
|
227 | options?: Options,
|
228 | callback?: Callback<ModelData>,
|
229 | ): PromiseOrVoid<ModelData>;
|
230 |
|
231 | findById(
|
232 | fkId: any,
|
233 | options?: Options,
|
234 | callback?: Callback<T>,
|
235 | ): PromiseOrVoid<T>;
|
236 |
|
237 | exists(
|
238 | fkId: any,
|
239 | options?: Options,
|
240 | callback?: Callback<boolean>,
|
241 | ): PromiseOrVoid<boolean>;
|
242 |
|
243 | updateById(
|
244 | fkId: any,
|
245 | data: PersistedData<T>,
|
246 | options?: Options,
|
247 | callback?: Callback<boolean>,
|
248 | ): PromiseOrVoid<boolean>;
|
249 |
|
250 | destroyById(
|
251 | fkId: any,
|
252 | options?: Options,
|
253 | callback?: Callback<boolean>,
|
254 | ): PromiseOrVoid<boolean>;
|
255 |
|
256 | at(
|
257 | index: number,
|
258 | options?: Options,
|
259 | callback?: Callback<T>,
|
260 | ): PromiseOrVoid<T>;
|
261 |
|
262 | create(
|
263 | targetModelData: PersistedData<T>,
|
264 | options?: Options,
|
265 | callback?: Callback<T>,
|
266 | ): PromiseOrVoid<T>;
|
267 |
|
268 | build(targetModelData: PersistedData<T>): T;
|
269 |
|
270 | add(
|
271 | acInst: any,
|
272 | options?: Options,
|
273 | callback?: Callback<boolean>,
|
274 | ): PromiseOrVoid<boolean>;
|
275 |
|
276 | remove(
|
277 | acInst: any,
|
278 | options?: Options,
|
279 | callback?: Callback<boolean>,
|
280 | ): PromiseOrVoid<boolean>;
|
281 | }
|
282 |
|
283 | export declare class EmbedsOne<
|
284 | S extends PersistedModel = PersistedModel,
|
285 | T extends PersistedModel = PersistedModel
|
286 | > extends Relation<S, T> {
|
287 | related(
|
288 | condOrRefresh: any,
|
289 | options?: Options,
|
290 | callback?: Callback<T>,
|
291 | ): PromiseOrVoid<T>;
|
292 |
|
293 | prepareEmbeddedInstance(inst: T): void;
|
294 |
|
295 | embeddedValue(modelInstance: S): T;
|
296 |
|
297 | create(
|
298 | targetModelData: PersistedData<T>,
|
299 | options?: Options,
|
300 | callback?: Callback<T>,
|
301 | ): PromiseOrVoid<T>;
|
302 |
|
303 | build(targetModelData: PersistedData<T>): T;
|
304 |
|
305 | update(
|
306 | targetModelData: PersistedData<T>,
|
307 | options?: Options,
|
308 | callback?: Callback<boolean>,
|
309 | ): PromiseOrVoid<boolean>;
|
310 |
|
311 | destroy(
|
312 | options?: Options,
|
313 | callback?: Callback<boolean>,
|
314 | ): PromiseOrVoid<boolean>;
|
315 | }
|
316 |
|
317 | export declare class EmbedsMany<
|
318 | S extends PersistedModel = PersistedModel,
|
319 | T extends PersistedModel = PersistedModel
|
320 | > extends Relation<S, T> {
|
321 | prepareEmbeddedInstance(inst: T): void;
|
322 |
|
323 | embeddedList(modelInstance: T[]): void;
|
324 |
|
325 | embeddedValue(modelInstance: S): T[];
|
326 |
|
327 | related(
|
328 | receiver: PersistedModelClass,
|
329 | scopeParams: AnyObject,
|
330 | condOrRefresh: any,
|
331 | options?: Options,
|
332 | callback?: Callback<ModelData>,
|
333 | ): PromiseOrVoid<ModelData>;
|
334 |
|
335 | findById(
|
336 | fkId: any,
|
337 | options?: Options,
|
338 | callback?: Callback<T>,
|
339 | ): PromiseOrVoid<T>;
|
340 |
|
341 | get(
|
342 | fkId: any,
|
343 | options?: Options,
|
344 | callback?: Callback<ModelData>,
|
345 | ): PromiseOrVoid<ModelData>;
|
346 |
|
347 | exists(
|
348 | fkId: any,
|
349 | options?: Options,
|
350 | callback?: Callback<boolean>,
|
351 | ): PromiseOrVoid<boolean>;
|
352 |
|
353 | updateById(
|
354 | fkId: any,
|
355 | data: PersistedData<T>,
|
356 | options?: Options,
|
357 | callback?: Callback<T>,
|
358 | ): PromiseOrVoid<T>;
|
359 |
|
360 | set(
|
361 | fkId: any,
|
362 | data: PersistedData<T>,
|
363 | options?: Options,
|
364 | callback?: Callback<boolean>,
|
365 | ): PromiseOrVoid<boolean>;
|
366 |
|
367 | destroyById(
|
368 | fkId: any,
|
369 | options?: Options,
|
370 | callback?: Callback<boolean>,
|
371 | ): PromiseOrVoid<boolean>;
|
372 |
|
373 | unset(
|
374 | fkId: any,
|
375 | options?: Options,
|
376 | callback?: Callback<boolean>,
|
377 | ): PromiseOrVoid<boolean>;
|
378 |
|
379 | destroyAll(
|
380 | where: Where,
|
381 | options?: Options,
|
382 | callback?: Callback<Count>,
|
383 | ): PromiseOrVoid<Count>;
|
384 |
|
385 | at(index: number, callback?: Callback<T>): PromiseOrVoid<T>;
|
386 |
|
387 | create(
|
388 | targetModelData: PersistedData<T>,
|
389 | options?: Options,
|
390 | callback?: Callback<T>,
|
391 | ): PromiseOrVoid<T>;
|
392 |
|
393 | build(targetModelData: PersistedData<T>): T;
|
394 |
|
395 | add(
|
396 | acInst: any,
|
397 | data: PersistedData<T>,
|
398 | options?: Options,
|
399 | callback?: Callback<boolean>,
|
400 | ): PromiseOrVoid<boolean>;
|
401 |
|
402 | remove(
|
403 | acInst: any,
|
404 | options?: Options,
|
405 | callback?: Callback<boolean>,
|
406 | ): PromiseOrVoid<boolean>;
|
407 | }
|