@expressive/sql 0.3.1 → 0.4.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.mts +132 -113
- package/dist/index.d.ts +132 -113
- package/dist/index.js +92 -92
- package/dist/index.mjs +90 -90
- package/package.json +1 -1
package/dist/index.d.mts
CHANGED
|
@@ -1,56 +1,71 @@
|
|
|
1
|
-
declare namespace
|
|
2
|
-
type
|
|
3
|
-
type Fields<T extends
|
|
1
|
+
declare namespace Table {
|
|
2
|
+
type Type<T extends Table = Table> = (abstract new () => T) & typeof Table;
|
|
3
|
+
type Fields<T extends Table, O extends Partial<Field> = never> = {
|
|
4
4
|
[K in keyof T]: T[K] extends Field ? T[K] extends O ? never : K : never;
|
|
5
5
|
}[keyof T];
|
|
6
|
-
type Required<T extends
|
|
7
|
-
type NonNull<T extends
|
|
8
|
-
type Insert<T extends
|
|
6
|
+
type Required<T extends Table> = Fields<T, Nullable | Optional>;
|
|
7
|
+
type NonNull<T extends Table> = Fields<T, Nullable>;
|
|
8
|
+
type Insert<T extends Table> = {
|
|
9
9
|
[K in Fields<T>]?: Field.Assigns<T[K]>;
|
|
10
10
|
} & {
|
|
11
11
|
[K in Required<T>]: Field.Assigns<T[K]>;
|
|
12
12
|
};
|
|
13
|
-
type Values<T extends
|
|
13
|
+
type Values<T extends Table> = {
|
|
14
14
|
"id": number;
|
|
15
15
|
} & {
|
|
16
16
|
[K in Fields<T>]: T[K] extends Field.Returns<infer U> ? U : never;
|
|
17
17
|
};
|
|
18
|
-
type Query<T extends
|
|
18
|
+
type Query<T extends Table, R> = (query: Query.From<T>, where: Query.Where) => R;
|
|
19
19
|
interface InsertOp extends PromiseLike<void> {
|
|
20
20
|
toString(): string;
|
|
21
21
|
}
|
|
22
22
|
}
|
|
23
|
-
declare abstract class
|
|
24
|
-
this: Type
|
|
23
|
+
declare abstract class Table {
|
|
24
|
+
this: Table.Type;
|
|
25
25
|
/**
|
|
26
26
|
* Primary key of this entity.
|
|
27
27
|
* May be any name in the actual database, however requred to be `id` as property of this type.
|
|
28
28
|
*/
|
|
29
|
-
id:
|
|
29
|
+
id: {
|
|
30
|
+
readonly type: "integer";
|
|
31
|
+
readonly nullable: false;
|
|
32
|
+
readonly optional: true;
|
|
33
|
+
readonly primary: true;
|
|
34
|
+
readonly unique: true;
|
|
35
|
+
readonly increment: boolean;
|
|
36
|
+
readonly tableName?: string | ((self: Table.Type) => string);
|
|
37
|
+
readonly tableSchema?: string | ((self: Table.Type) => string);
|
|
38
|
+
readonly columnName?: (property: string, column: Field, self: Table.Type) => string;
|
|
39
|
+
init(property: string, parent: Table.Type): void;
|
|
40
|
+
absent: boolean;
|
|
41
|
+
fallback?: unknown;
|
|
42
|
+
column: string;
|
|
43
|
+
property: string;
|
|
44
|
+
parent: Table.Type;
|
|
45
|
+
table?: Query.ITable;
|
|
46
|
+
query?: Builder;
|
|
47
|
+
reference?: Field;
|
|
48
|
+
readonly datatype: string;
|
|
49
|
+
use?(query: Builder): unknown;
|
|
50
|
+
set(value: number): any;
|
|
51
|
+
get(value: any): number;
|
|
52
|
+
};
|
|
30
53
|
static schema: string;
|
|
31
54
|
static connection?: Connection;
|
|
32
55
|
static get fields(): Map<string, Field<unknown>>;
|
|
33
56
|
static get table(): string;
|
|
34
57
|
static set table(value: string);
|
|
35
58
|
static toString(): string;
|
|
36
|
-
static is(obj: unknown): obj is Type
|
|
37
|
-
static insert<T extends
|
|
38
|
-
static insert<T extends
|
|
39
|
-
static insert<T extends
|
|
40
|
-
static get<T extends
|
|
41
|
-
static get<T extends
|
|
42
|
-
static get<T extends
|
|
43
|
-
static one<T extends
|
|
44
|
-
static one<T extends
|
|
45
|
-
static one<T extends
|
|
46
|
-
}
|
|
47
|
-
declare class Primary extends Field<number> {
|
|
48
|
-
readonly type = "integer";
|
|
49
|
-
readonly increment = true;
|
|
50
|
-
readonly optional = true;
|
|
51
|
-
readonly nullable = false;
|
|
52
|
-
readonly primary = true;
|
|
53
|
-
readonly unique = true;
|
|
59
|
+
static is(obj: unknown): obj is Table.Type;
|
|
60
|
+
static insert<T extends Table>(this: Table.Type<T>, entries: Table.Insert<T> | Table.Insert<T>[]): Query<number>;
|
|
61
|
+
static insert<T extends Table>(this: Table.Type<T>, number: number, map: (index: number) => Table.Insert<T>): Query<number>;
|
|
62
|
+
static insert<T extends Table, I>(this: Table.Type<T>, forEach: Array<I>, map: (value: I, index: number) => Table.Insert<T>): Query<number>;
|
|
63
|
+
static get<T extends Table>(this: Table.Type<T>, limit?: number): Query.Selects<T>;
|
|
64
|
+
static get<T extends Table>(this: Table.Type<T>, where?: Table.Query<T, void>): Query.Selects<T>;
|
|
65
|
+
static get<T extends Table, R>(this: Table.Type<T>, limit: number, where: Table.Query<T, R>): Query.Selects<R>;
|
|
66
|
+
static one<T extends Table, R extends {}>(this: Table.Type<T>, query: Table.Query<T, R>): Promise<Query.Returns<R>>;
|
|
67
|
+
static one<T extends Table>(this: Table.Type<T>, query?: Table.Query<T, void>): Promise<Table.Values<T>>;
|
|
68
|
+
static one<T extends Table>(this: Table.Type<T>, id: number): Promise<Table.Values<T>>;
|
|
54
69
|
}
|
|
55
70
|
|
|
56
71
|
type ANumeric = Query.Match<string | number>;
|
|
@@ -93,8 +108,8 @@ declare class Generator {
|
|
|
93
108
|
protected value(input: unknown): string;
|
|
94
109
|
protected jsonTable(table: DataTable): void;
|
|
95
110
|
computed(from: Computed<any>): string;
|
|
96
|
-
protected joins(main: Builder.
|
|
97
|
-
protected set(updates: Map<Query.
|
|
111
|
+
protected joins(main: Builder.ITable): string | undefined;
|
|
112
|
+
protected set(updates: Map<Query.ITable, Builder.Insert>): string;
|
|
98
113
|
protected update(multiTableAllowed?: boolean): (string | undefined)[] | undefined;
|
|
99
114
|
protected delete(): (string | false | undefined)[] | undefined;
|
|
100
115
|
protected reference(from: unknown): string;
|
|
@@ -108,18 +123,18 @@ declare class Generator {
|
|
|
108
123
|
}
|
|
109
124
|
|
|
110
125
|
declare namespace Connection {
|
|
111
|
-
type Types = typeof
|
|
112
|
-
[key: string | number]: typeof
|
|
126
|
+
type Types = typeof Table[] | {
|
|
127
|
+
[key: string | number]: typeof Table;
|
|
113
128
|
};
|
|
114
129
|
type Using = {
|
|
115
|
-
[key: string | number]: typeof
|
|
130
|
+
[key: string | number]: typeof Table;
|
|
116
131
|
};
|
|
117
132
|
type Ready<T extends Connection = Connection> = Omit<T, "then">;
|
|
118
133
|
let None: Connection;
|
|
119
134
|
}
|
|
120
135
|
declare abstract class Connection {
|
|
121
136
|
static generator: typeof Generator;
|
|
122
|
-
readonly using: Readonly<Set<typeof
|
|
137
|
+
readonly using: Readonly<Set<typeof Table>>;
|
|
123
138
|
readonly ready: boolean;
|
|
124
139
|
constructor(using: Connection.Types);
|
|
125
140
|
generate(builder: Builder): string;
|
|
@@ -127,7 +142,7 @@ declare abstract class Connection {
|
|
|
127
142
|
abstract get schema(): string;
|
|
128
143
|
close(): Promise<void>;
|
|
129
144
|
abstract sync(fix?: boolean): Promise<this>;
|
|
130
|
-
abstract valid(type: Type
|
|
145
|
+
abstract valid(type: Table.Type): Promise<boolean>;
|
|
131
146
|
abstract prepare<T = any>(query: string): {
|
|
132
147
|
all: (args?: any[]) => Promise<T[]>;
|
|
133
148
|
get: (args?: any[]) => Promise<T | undefined>;
|
|
@@ -136,24 +151,24 @@ declare abstract class Connection {
|
|
|
136
151
|
}
|
|
137
152
|
|
|
138
153
|
declare namespace Query {
|
|
139
|
-
type
|
|
140
|
-
type From<T extends
|
|
141
|
-
[K in
|
|
154
|
+
type ITable = Builder.ITable;
|
|
155
|
+
type From<T extends Table = Table> = {
|
|
156
|
+
[K in Table.Fields<T>]: T[K] extends Field.Queries<infer U> ? U : T[K];
|
|
142
157
|
};
|
|
143
|
-
type Join<T extends
|
|
144
|
-
[K in
|
|
158
|
+
type Join<T extends Table = Table> = {
|
|
159
|
+
[K in Table.Fields<T>]?: T[K] extends Field.Queries<infer U> ? U : T[K];
|
|
145
160
|
};
|
|
146
|
-
type Update<T extends
|
|
147
|
-
[K in
|
|
161
|
+
type Update<T extends Table> = {
|
|
162
|
+
[K in Table.Fields<T>]?: Updates<T[K]>;
|
|
148
163
|
};
|
|
149
164
|
type FromData<T extends {}> = {
|
|
150
165
|
[K in keyof T]: Field<T[K]>;
|
|
151
166
|
};
|
|
152
167
|
type Match<T = any> = T | (T extends Field<infer U> ? Match<U> : Field<T> | Computed<T>);
|
|
153
|
-
type Insert<T extends
|
|
154
|
-
[K in
|
|
168
|
+
type Insert<T extends Table> = {
|
|
169
|
+
[K in Table.Required<T>]: Field.Assigns<T[K]> | Field;
|
|
155
170
|
} & {
|
|
156
|
-
[K in
|
|
171
|
+
[K in Table.Fields<T>]?: Field.Assigns<T[K]> | Field;
|
|
157
172
|
};
|
|
158
173
|
interface Functions extends MathOps {
|
|
159
174
|
(template: string): QueryTemplate;
|
|
@@ -174,21 +189,21 @@ declare namespace Query {
|
|
|
174
189
|
/**
|
|
175
190
|
* Declare inserts to be made into a given table.
|
|
176
191
|
*/
|
|
177
|
-
<T extends
|
|
192
|
+
<T extends Table>(entity: Table.Type<T>, ...inserts: Insert<T>[]): From<T>;
|
|
178
193
|
/**
|
|
179
194
|
* Create a reference to the primary table, returned
|
|
180
195
|
* object can be used to query against that table.
|
|
181
196
|
*/
|
|
182
|
-
<T extends
|
|
197
|
+
<T extends Table>(entity: Table.Type<T>): From<T>;
|
|
183
198
|
/**
|
|
184
199
|
* Registers a type as a left join, returned object has optional
|
|
185
200
|
* properties which may be undefined where the join is not present.
|
|
186
201
|
*/
|
|
187
|
-
<T extends
|
|
202
|
+
<T extends Table>(entity: Table.Type<T>, optional: true): Join<T>;
|
|
188
203
|
/**
|
|
189
204
|
* Select a table for comparison or write operations.
|
|
190
205
|
*/
|
|
191
|
-
<T extends
|
|
206
|
+
<T extends Table>(field: From<T> | Join<T>): Verbs<T>;
|
|
192
207
|
/**
|
|
193
208
|
* Prepare comparison against a particilar field,
|
|
194
209
|
* returns operations for the given type.
|
|
@@ -200,7 +215,7 @@ declare namespace Query {
|
|
|
200
215
|
connection: Connection.Ready;
|
|
201
216
|
};
|
|
202
217
|
type Compare<T> = {
|
|
203
|
-
|
|
218
|
+
equal(value: Match<T>): Expression;
|
|
204
219
|
not(value: Match<T>): Expression;
|
|
205
220
|
over(value: Match<T>, orEqual?: boolean): Expression;
|
|
206
221
|
under(value: Match<T>, orEqual?: boolean): Expression;
|
|
@@ -216,11 +231,11 @@ declare namespace Query {
|
|
|
216
231
|
type Template<A extends any[]> = (...args: A) => Query;
|
|
217
232
|
type TemplateSelects<T, A extends any[]> = (...args: A) => Selects<T>;
|
|
218
233
|
type Returns<T> = T extends Field.Returns<infer R> ? R : T extends From<infer U> ? {
|
|
219
|
-
[J in
|
|
234
|
+
[J in Table.Fields<U>]: Returns<U[J]>;
|
|
220
235
|
} : T extends {} ? {
|
|
221
236
|
[K in keyof T]: Returns<T[K]>;
|
|
222
237
|
} : T;
|
|
223
|
-
interface Verbs<T extends
|
|
238
|
+
interface Verbs<T extends Table> {
|
|
224
239
|
delete(): void;
|
|
225
240
|
update(values: Update<T>): void;
|
|
226
241
|
}
|
|
@@ -260,7 +275,7 @@ declare namespace Query {
|
|
|
260
275
|
}
|
|
261
276
|
|
|
262
277
|
declare namespace Builder {
|
|
263
|
-
interface
|
|
278
|
+
interface ITable<T extends Table = any> {
|
|
264
279
|
toString(): string;
|
|
265
280
|
name: string;
|
|
266
281
|
proxy: Query.From<T>;
|
|
@@ -269,7 +284,7 @@ declare namespace Builder {
|
|
|
269
284
|
optional?: boolean;
|
|
270
285
|
joins: Cond[];
|
|
271
286
|
}
|
|
272
|
-
type Using<T extends
|
|
287
|
+
type Using<T extends Table> = (self: Query.From<T>, where: Query.Where) => void;
|
|
273
288
|
type Insert = Map<Field, unknown>;
|
|
274
289
|
}
|
|
275
290
|
declare class Builder {
|
|
@@ -282,18 +297,18 @@ declare class Builder {
|
|
|
282
297
|
filters: Group;
|
|
283
298
|
pending: Set<() => void>;
|
|
284
299
|
order: Map<Field<unknown>, "asc" | "desc">;
|
|
285
|
-
tables: Map<{}, Query.
|
|
286
|
-
deletes: Set<Query.
|
|
287
|
-
updates: Map<Query.
|
|
288
|
-
inserts: Map<Query.
|
|
300
|
+
tables: Map<{}, Query.ITable>;
|
|
301
|
+
deletes: Set<Query.ITable>;
|
|
302
|
+
updates: Map<Query.ITable, Builder.Insert>;
|
|
303
|
+
inserts: Map<Query.ITable, Builder.Insert>;
|
|
289
304
|
register: Map<string, Field<unknown>>;
|
|
290
305
|
returns?: Map<string, Field | Value> | Field | Value;
|
|
291
306
|
limit?: number;
|
|
292
307
|
commit(returns: unknown): void;
|
|
293
308
|
inject(args: number): (() => Parameter)[];
|
|
294
|
-
table(table: Query.From): Query.Verbs<
|
|
309
|
+
table(table: Query.From): Query.Verbs<Table>;
|
|
295
310
|
compare<T extends Field>(field: T): {
|
|
296
|
-
|
|
311
|
+
equal: (right: unknown, orEqual?: boolean) => Expression;
|
|
297
312
|
in: (right: unknown, orEqual?: boolean) => Expression;
|
|
298
313
|
not: (right: unknown, orEqual?: boolean) => Expression;
|
|
299
314
|
over: (right: unknown, orEqual?: boolean) => Expression;
|
|
@@ -302,17 +317,17 @@ declare class Builder {
|
|
|
302
317
|
field<T extends Field>(field: T): {
|
|
303
318
|
asc: () => void;
|
|
304
319
|
desc: () => void;
|
|
305
|
-
|
|
320
|
+
equal: (right: unknown, orEqual?: boolean) => Expression;
|
|
306
321
|
in: (right: unknown, orEqual?: boolean) => Expression;
|
|
307
322
|
not: (right: unknown, orEqual?: boolean) => Expression;
|
|
308
323
|
over: (right: unknown, orEqual?: boolean) => Expression;
|
|
309
324
|
under: (right: unknown, orEqual?: boolean) => Expression;
|
|
310
325
|
};
|
|
311
326
|
andOr(...args: Expression[]): Group;
|
|
312
|
-
use<T extends
|
|
313
|
-
use<T extends
|
|
314
|
-
use<T extends
|
|
315
|
-
insert<T extends
|
|
327
|
+
use<T extends Table>(type: Table.Type<T>, optional?: false): Query.From<T>;
|
|
328
|
+
use<T extends Table>(type: Table.Type<T>, optional: boolean): Query.Join<T>;
|
|
329
|
+
use<T extends Table>(type: Table.Type<T>, ...inserts: Table.Insert<T>[]): Query.From<T>;
|
|
330
|
+
insert<T extends Table>(table: Builder.ITable<T>, input: Table.Insert<T>): void;
|
|
316
331
|
digest(value: any, field: Field): any;
|
|
317
332
|
where(left: Field, op: string, right: unknown): Expression;
|
|
318
333
|
with<T extends Record<string, any>>(data: Iterable<T>): { [K in keyof T]: Field<T[K]>; };
|
|
@@ -335,7 +350,7 @@ declare class DataField extends Value {
|
|
|
335
350
|
constructor(column: string, table: DataTable);
|
|
336
351
|
get datatype(): string;
|
|
337
352
|
}
|
|
338
|
-
declare class DataTable<T extends Record<string, unknown> = any> extends Parameter implements Builder.
|
|
353
|
+
declare class DataTable<T extends Record<string, unknown> = any> extends Parameter implements Builder.ITable {
|
|
339
354
|
parent: Builder;
|
|
340
355
|
proxy: {
|
|
341
356
|
[K in keyof T]: Field<T[K]>;
|
|
@@ -379,19 +394,20 @@ type Optional = {
|
|
|
379
394
|
};
|
|
380
395
|
declare namespace Field {
|
|
381
396
|
type Init<T extends Field = Field> = (self: T) => Partial<T> | void;
|
|
382
|
-
type
|
|
383
|
-
type
|
|
384
|
-
|
|
385
|
-
}
|
|
397
|
+
type Args<T extends Field = Field> = (Partial<T> | null | string)[];
|
|
398
|
+
type Type<T extends any[], A, D extends Field = any> = T extends [infer First, ...infer Rest] ? First extends {
|
|
399
|
+
type: infer I;
|
|
400
|
+
} ? (I extends keyof A ? A[I] : D) : Type<Rest, A, D> : A extends {
|
|
401
|
+
default: infer V;
|
|
402
|
+
} ? V : D;
|
|
403
|
+
type Mod<T extends any[], TT> = T extends [infer First, ...infer Rest] ? First extends {
|
|
404
|
+
nullable?: true;
|
|
405
|
+
optional?: true;
|
|
406
|
+
} | null ? TT & Nullable : First extends {
|
|
386
407
|
fallback?: any;
|
|
387
408
|
increment?: true;
|
|
388
|
-
} ? TT & Optional : TT;
|
|
389
|
-
type
|
|
390
|
-
type: infer U;
|
|
391
|
-
} ? (U extends keyof A ? A[U] : D) : A extends {
|
|
392
|
-
default: infer U;
|
|
393
|
-
} ? U : D;
|
|
394
|
-
type Infer<T, A, D extends Field = any> = Modifier<T, Type<T, A, D>>;
|
|
409
|
+
} ? TT & Optional : Mod<Rest, TT> : TT;
|
|
410
|
+
type Infer<T extends any[], A, D extends Field = any> = Mod<T, Type<T, A, D>>;
|
|
395
411
|
type Returns<T> = Field & {
|
|
396
412
|
get(value: any): T;
|
|
397
413
|
};
|
|
@@ -411,19 +427,20 @@ declare class Field<T = unknown> {
|
|
|
411
427
|
unique: boolean;
|
|
412
428
|
nullable: boolean;
|
|
413
429
|
optional: boolean;
|
|
430
|
+
absent: boolean;
|
|
414
431
|
increment: boolean;
|
|
415
432
|
fallback?: unknown;
|
|
416
433
|
column: string;
|
|
417
434
|
property: string;
|
|
418
|
-
parent: Type
|
|
419
|
-
table?: Query.
|
|
435
|
+
parent: Table.Type;
|
|
436
|
+
table?: Query.ITable;
|
|
420
437
|
query?: Builder;
|
|
421
438
|
/** If column has a reference constraint, applicable field is listed here. */
|
|
422
439
|
reference?: Field;
|
|
423
440
|
/** Real datatype of this field in database. */
|
|
424
441
|
get datatype(): string;
|
|
425
|
-
static new<T extends Field>(this: new (...args: any[]) => T, options
|
|
426
|
-
|
|
442
|
+
static new<T extends Field>(this: new (...args: any[]) => T, ...options: Field.Args<T>): Field;
|
|
443
|
+
init?(property: string, parent: Table.Type): void;
|
|
427
444
|
/**
|
|
428
445
|
* Optional method generates value of property this Field is applied to when accessed inside a query.
|
|
429
446
|
* If not defined, the value will be the Field itself.
|
|
@@ -445,7 +462,7 @@ declare class Field<T = unknown> {
|
|
|
445
462
|
*/
|
|
446
463
|
get(value: any): T;
|
|
447
464
|
}
|
|
448
|
-
type Callback = (parent: Type
|
|
465
|
+
type Callback = (parent: Table.Type, property: string) => void;
|
|
449
466
|
|
|
450
467
|
declare class BooleanColumn extends Field<boolean> {
|
|
451
468
|
readonly type: Bool.DataType;
|
|
@@ -480,11 +497,10 @@ declare namespace Bool {
|
|
|
480
497
|
type DataType = keyof Types;
|
|
481
498
|
/** All available database types for Bool */
|
|
482
499
|
type Any = Types[keyof Types] | BooleanColumn;
|
|
483
|
-
type
|
|
500
|
+
type Options = Field.Args<Any>;
|
|
484
501
|
}
|
|
485
502
|
type Bool = Bool.Any;
|
|
486
|
-
declare function Bool<T extends
|
|
487
|
-
declare function Bool<T extends Bool.Opts>(opts?: T): Field.Infer<T, Bool.Types, Bool>;
|
|
503
|
+
declare function Bool<T extends Bool.Options>(...opts: T): Field.Infer<T, Bool.Types, Bool>;
|
|
488
504
|
declare namespace Bool {
|
|
489
505
|
var Type: typeof BooleanColumn;
|
|
490
506
|
}
|
|
@@ -529,37 +545,34 @@ declare namespace Num {
|
|
|
529
545
|
type DataType = keyof Types;
|
|
530
546
|
/** All available database types for Num */
|
|
531
547
|
type Any = Types[keyof Types] | NumericColumn;
|
|
532
|
-
type Opts =
|
|
548
|
+
type Opts = Field.Args<Any>;
|
|
533
549
|
}
|
|
534
550
|
type Num = Num.Any;
|
|
535
|
-
declare function Num<T extends
|
|
536
|
-
declare function Num<T extends Num.Opts>(opts?: T): Field.Infer<T, Num.Types, Num>;
|
|
551
|
+
declare function Num<T extends Num.Opts>(...opts: T): Field.Infer<T, Num.Types, Num>;
|
|
537
552
|
declare namespace Num {
|
|
538
553
|
var Type: typeof NumericColumn;
|
|
539
554
|
}
|
|
540
555
|
|
|
541
|
-
declare class ForeignColumn<T extends
|
|
556
|
+
declare class ForeignColumn<T extends Table = Table> extends Field<Table.Values<T>> {
|
|
542
557
|
readonly type: One.DataType;
|
|
543
|
-
readonly entity: Type
|
|
558
|
+
readonly entity: Table.Type<T>;
|
|
544
559
|
readonly nullable: boolean;
|
|
545
560
|
readonly onDelete?: string;
|
|
546
561
|
readonly onUpdate?: string;
|
|
547
|
-
set(value:
|
|
548
|
-
use(query: Builder):
|
|
562
|
+
set(value: Table.Values<T> | number): any;
|
|
563
|
+
use(query: Builder): Query.From<T>;
|
|
549
564
|
}
|
|
550
565
|
declare namespace One {
|
|
551
566
|
interface Types {
|
|
552
567
|
}
|
|
553
568
|
type DataType = keyof Types;
|
|
554
|
-
type Options = {
|
|
569
|
+
type Options = (null | string | {
|
|
555
570
|
[K in Exclude<keyof ForeignColumn, 'entity'>]?: ForeignColumn[K];
|
|
556
|
-
};
|
|
571
|
+
})[];
|
|
557
572
|
}
|
|
558
|
-
interface One<T extends
|
|
573
|
+
interface One<T extends Table> extends ForeignColumn<T> {
|
|
559
574
|
}
|
|
560
|
-
declare function One<T extends
|
|
561
|
-
declare function One<T extends Type>(entity: Type.EntityType<T>, nullable: boolean): One<T> & Nullable;
|
|
562
|
-
declare function One<T extends Type, O extends One.Options>(entity: Type.EntityType<T>, options: O): Field.Modifier<O, One<T>>;
|
|
575
|
+
declare function One<T extends Table, O extends One.Options>(entity: Table.Type<T>, ...options: O): Field.Mod<O, One<T>>;
|
|
563
576
|
declare namespace One {
|
|
564
577
|
var Type: typeof ForeignColumn;
|
|
565
578
|
}
|
|
@@ -601,11 +614,10 @@ declare namespace Str {
|
|
|
601
614
|
type DataType = keyof Types;
|
|
602
615
|
/** All available database types for Str */
|
|
603
616
|
type Any = Types[keyof Types] | StringColumn;
|
|
604
|
-
type Options =
|
|
617
|
+
type Options = Field.Args<Any>;
|
|
605
618
|
}
|
|
606
619
|
type Str = Str.Any;
|
|
607
|
-
declare function Str<T extends
|
|
608
|
-
declare function Str<T extends Str.Options>(opts?: T): Field.Infer<T, Str.Types, Str>;
|
|
620
|
+
declare function Str<T extends Str.Options>(...opts: T): Field.Infer<T, Str.Types, Str>;
|
|
609
621
|
declare namespace Str {
|
|
610
622
|
var Type: typeof StringColumn;
|
|
611
623
|
}
|
|
@@ -645,22 +657,29 @@ declare namespace Time {
|
|
|
645
657
|
type DataType = keyof Types;
|
|
646
658
|
/** All available database types for Time */
|
|
647
659
|
type Any = Types[keyof Types] | TimeColumn;
|
|
648
|
-
type Options =
|
|
660
|
+
type Options = Field.Args<Any>;
|
|
649
661
|
}
|
|
650
662
|
type Time = Time.Any;
|
|
651
|
-
declare function Time<T extends
|
|
652
|
-
declare function Time<T extends Time.Options>(opts?: T): Field.Infer<T, Time.Types, Time>;
|
|
663
|
+
declare function Time<T extends Time.Options>(...opts: T): Field.Infer<T, Time.Types, Time>;
|
|
653
664
|
declare namespace Time {
|
|
654
665
|
var Type: typeof TimeColumn;
|
|
655
666
|
}
|
|
656
667
|
|
|
657
|
-
declare
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
|
|
668
|
+
declare class PrimaryColumn extends Field<number> {
|
|
669
|
+
readonly type = "integer";
|
|
670
|
+
readonly nullable = false;
|
|
671
|
+
readonly optional = true;
|
|
672
|
+
readonly primary = true;
|
|
673
|
+
readonly unique = true;
|
|
674
|
+
readonly increment: boolean;
|
|
675
|
+
readonly tableName?: string | ((self: Table.Type) => string);
|
|
676
|
+
readonly tableSchema?: string | ((self: Table.Type) => string);
|
|
677
|
+
readonly columnName?: (property: string, column: Field, self: Table.Type) => string;
|
|
678
|
+
init(property: string, parent: Table.Type): void;
|
|
679
|
+
}
|
|
680
|
+
declare namespace Primary {
|
|
681
|
+
type Options = Field.Args<PrimaryColumn>;
|
|
662
682
|
}
|
|
663
|
-
declare function
|
|
664
|
-
declare function Table(opts: Table.Options): Type.EntityType;
|
|
683
|
+
declare function Primary<A extends Primary.Options>(...opts: A): Field.Infer<A, {}, PrimaryColumn>;
|
|
665
684
|
|
|
666
|
-
export { Bool, Builder, Connection, DataTable, Field, Generator, type Nullable, Num, One, type Optional, Parameter, Query, Str, Table, Time
|
|
685
|
+
export { Bool, Builder, Connection, DataTable, Field, Generator, type Nullable, Num, One, type Optional, Parameter, Primary, Query, Str, Table, Time };
|