UNPKG

9.05 kBTypeScriptView Raw
1// Copyright IBM Corp. 2018. All Rights Reserved.
2// Node module: loopback-datasource-juggler
3// This file is licensed under the MIT License.
4// License text available at https://opensource.org/licenses/MIT
5
6import {AnyObject, Callback, Options, PromiseOrVoid} from './common';
7import {ModelData} from './model';
8import {
9 Count,
10 PersistedData,
11 PersistedModel,
12 PersistedModelClass,
13} from './persisted-model';
14import {Filter, Where} from './query';
15
16/**
17 * Relation types
18 */
19export 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 * Relation definition
31 */
32export 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 * Relation of a given model instance
57 */
58export 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
74export 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
106export 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
140export 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
182export 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
214export declare class HasAndBelongsToMany<
215 S extends PersistedModel = PersistedModel,
216 T extends PersistedModel = PersistedModel
217> extends Relation<S, T> {}
218
219export 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
283export 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
317export 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}