@expressive/sql 0.3.0 → 0.4.0
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 +163 -143
- package/dist/index.d.ts +163 -143
- package/dist/index.js +106 -117
- package/dist/index.mjs +104 -115
- package/package.json +2 -1
package/dist/index.d.mts
CHANGED
|
@@ -1,60 +1,75 @@
|
|
|
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
|
-
type ANumeric = Query.
|
|
57
|
-
type Numeric = Query.
|
|
71
|
+
type ANumeric = Query.Match<string | number>;
|
|
72
|
+
type Numeric = Query.Match<number>;
|
|
58
73
|
interface Bitwise {
|
|
59
74
|
not(value: Numeric): Numeric;
|
|
60
75
|
and(left: Numeric, right: Numeric): Numeric;
|
|
@@ -75,8 +90,8 @@ interface MathOps {
|
|
|
75
90
|
}
|
|
76
91
|
declare const MathOps: MathOps;
|
|
77
92
|
declare class Computed<T> extends Value {
|
|
78
|
-
readonly left?: Query.
|
|
79
|
-
readonly right: Query.
|
|
93
|
+
readonly left?: Query.Match | Field<T> | Computed<T>;
|
|
94
|
+
readonly right: Query.Match | Field<T> | Computed<T>;
|
|
80
95
|
readonly operator: string;
|
|
81
96
|
readonly rank: number;
|
|
82
97
|
constructor(operator: string, value: Value | Field<T> | Computed<T>, right?: Value | Field<T> | Computed<T>, rank?: 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
|
-
type
|
|
153
|
-
type Insert<T extends
|
|
154
|
-
[K in
|
|
167
|
+
type Match<T = any> = T | (T extends Field<infer U> ? Match<U> : Field<T> | Computed<T>);
|
|
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;
|
|
@@ -170,25 +185,25 @@ declare namespace Query {
|
|
|
170
185
|
*
|
|
171
186
|
* Will alternate between AND-OR depending on depth, starting with OR.
|
|
172
187
|
*/
|
|
173
|
-
(...orWhere:
|
|
188
|
+
(...orWhere: Expression[]): Group;
|
|
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.
|
|
@@ -199,22 +214,28 @@ declare namespace Query {
|
|
|
199
214
|
};
|
|
200
215
|
connection: Connection.Ready;
|
|
201
216
|
};
|
|
202
|
-
type Compare<T
|
|
217
|
+
type Compare<T> = {
|
|
218
|
+
equal(value: Match<T>): Expression;
|
|
219
|
+
not(value: Match<T>): Expression;
|
|
220
|
+
over(value: Match<T>, orEqual?: boolean): Expression;
|
|
221
|
+
under(value: Match<T>, orEqual?: boolean): Expression;
|
|
222
|
+
in(value: Match<T>[]): Expression;
|
|
223
|
+
};
|
|
203
224
|
type Asserts<T extends Field> = Compare<T> & {
|
|
204
225
|
asc(): void;
|
|
205
226
|
desc(): void;
|
|
206
227
|
};
|
|
207
228
|
type Updates<T> = Field.Updates<T> | T | Field;
|
|
208
|
-
type Function<R> = (this: Builder, where: Where, fn:
|
|
229
|
+
type Function<R> = (this: Builder, where: Where, fn: Functions) => R;
|
|
209
230
|
type Factory<R, A extends any[]> = Function<(...args: A) => R>;
|
|
210
231
|
type Template<A extends any[]> = (...args: A) => Query;
|
|
211
232
|
type TemplateSelects<T, A extends any[]> = (...args: A) => Selects<T>;
|
|
212
233
|
type Returns<T> = T extends Field.Returns<infer R> ? R : T extends From<infer U> ? {
|
|
213
|
-
[J in
|
|
234
|
+
[J in Table.Fields<U>]: Returns<U[J]>;
|
|
214
235
|
} : T extends {} ? {
|
|
215
236
|
[K in keyof T]: Returns<T[K]>;
|
|
216
237
|
} : T;
|
|
217
|
-
interface Verbs<T extends
|
|
238
|
+
interface Verbs<T extends Table> {
|
|
218
239
|
delete(): void;
|
|
219
240
|
update(values: Update<T>): void;
|
|
220
241
|
}
|
|
@@ -254,7 +275,7 @@ declare namespace Query {
|
|
|
254
275
|
}
|
|
255
276
|
|
|
256
277
|
declare namespace Builder {
|
|
257
|
-
interface
|
|
278
|
+
interface ITable<T extends Table = any> {
|
|
258
279
|
toString(): string;
|
|
259
280
|
name: string;
|
|
260
281
|
proxy: Query.From<T>;
|
|
@@ -263,7 +284,7 @@ declare namespace Builder {
|
|
|
263
284
|
optional?: boolean;
|
|
264
285
|
joins: Cond[];
|
|
265
286
|
}
|
|
266
|
-
type Using<T extends
|
|
287
|
+
type Using<T extends Table> = (self: Query.From<T>, where: Query.Where) => void;
|
|
267
288
|
type Insert = Map<Field, unknown>;
|
|
268
289
|
}
|
|
269
290
|
declare class Builder {
|
|
@@ -276,32 +297,39 @@ declare class Builder {
|
|
|
276
297
|
filters: Group;
|
|
277
298
|
pending: Set<() => void>;
|
|
278
299
|
order: Map<Field<unknown>, "asc" | "desc">;
|
|
279
|
-
tables: Map<{}, Query.
|
|
280
|
-
deletes: Set<Query.
|
|
281
|
-
updates: Map<Query.
|
|
282
|
-
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>;
|
|
283
304
|
register: Map<string, Field<unknown>>;
|
|
284
305
|
returns?: Map<string, Field | Value> | Field | Value;
|
|
285
306
|
limit?: number;
|
|
286
307
|
commit(returns: unknown): void;
|
|
287
308
|
inject(args: number): (() => Parameter)[];
|
|
288
|
-
table(table: Query.From): Query.Verbs<
|
|
309
|
+
table(table: Query.From): Query.Verbs<Table>;
|
|
310
|
+
compare<T extends Field>(field: T): {
|
|
311
|
+
equal: (right: unknown, orEqual?: boolean) => Expression;
|
|
312
|
+
in: (right: unknown, orEqual?: boolean) => Expression;
|
|
313
|
+
not: (right: unknown, orEqual?: boolean) => Expression;
|
|
314
|
+
over: (right: unknown, orEqual?: boolean) => Expression;
|
|
315
|
+
under: (right: unknown, orEqual?: boolean) => Expression;
|
|
316
|
+
};
|
|
289
317
|
field<T extends Field>(field: T): {
|
|
290
318
|
asc: () => void;
|
|
291
319
|
desc: () => void;
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
320
|
+
equal: (right: unknown, orEqual?: boolean) => Expression;
|
|
321
|
+
in: (right: unknown, orEqual?: boolean) => Expression;
|
|
322
|
+
not: (right: unknown, orEqual?: boolean) => Expression;
|
|
323
|
+
over: (right: unknown, orEqual?: boolean) => Expression;
|
|
324
|
+
under: (right: unknown, orEqual?: boolean) => Expression;
|
|
297
325
|
};
|
|
298
|
-
andOr(...args:
|
|
299
|
-
use<T extends
|
|
300
|
-
use<T extends
|
|
301
|
-
use<T extends
|
|
302
|
-
insert<T extends
|
|
326
|
+
andOr(...args: Expression[]): Group;
|
|
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;
|
|
303
331
|
digest(value: any, field: Field): any;
|
|
304
|
-
where(left: Field, op: string, right: unknown):
|
|
332
|
+
where(left: Field, op: string, right: unknown): Expression;
|
|
305
333
|
with<T extends Record<string, any>>(data: Iterable<T>): { [K in keyof T]: Field<T[K]>; };
|
|
306
334
|
accept(args: unknown[]): unknown[];
|
|
307
335
|
parse(raw: Record<string, any>): any;
|
|
@@ -322,7 +350,7 @@ declare class DataField extends Value {
|
|
|
322
350
|
constructor(column: string, table: DataTable);
|
|
323
351
|
get datatype(): string;
|
|
324
352
|
}
|
|
325
|
-
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 {
|
|
326
354
|
parent: Builder;
|
|
327
355
|
proxy: {
|
|
328
356
|
[K in keyof T]: Field<T[K]>;
|
|
@@ -338,6 +366,7 @@ declare class DataTable<T extends Record<string, unknown> = any> extends Paramet
|
|
|
338
366
|
constructor(parent: Builder, input: Iterable<T>);
|
|
339
367
|
toParam(): any;
|
|
340
368
|
}
|
|
369
|
+
type Expression = Cond | Group;
|
|
341
370
|
declare class Cond {
|
|
342
371
|
readonly left: Field;
|
|
343
372
|
readonly op: string;
|
|
@@ -346,9 +375,9 @@ declare class Cond {
|
|
|
346
375
|
constructor(left: Field, op: string, right: unknown, restricted?: boolean);
|
|
347
376
|
}
|
|
348
377
|
declare class Group {
|
|
349
|
-
children: Set<
|
|
350
|
-
add(left: Field |
|
|
351
|
-
delete(child:
|
|
378
|
+
children: Set<Expression>;
|
|
379
|
+
add(left: Field | Expression, op?: string, right?: unknown): Expression;
|
|
380
|
+
delete(child: Expression): void;
|
|
352
381
|
get size(): number;
|
|
353
382
|
}
|
|
354
383
|
declare class QueryTemplate extends Value {
|
|
@@ -365,19 +394,20 @@ type Optional = {
|
|
|
365
394
|
};
|
|
366
395
|
declare namespace Field {
|
|
367
396
|
type Init<T extends Field = Field> = (self: T) => Partial<T> | void;
|
|
368
|
-
type
|
|
369
|
-
type
|
|
370
|
-
|
|
371
|
-
} ?
|
|
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 {
|
|
372
407
|
fallback?: any;
|
|
373
408
|
increment?: true;
|
|
374
|
-
} ? TT & Optional : TT;
|
|
375
|
-
type
|
|
376
|
-
type: infer U;
|
|
377
|
-
} ? (U extends keyof TS ? TS[U] : D) : TS extends {
|
|
378
|
-
default: infer U;
|
|
379
|
-
} ? U : D;
|
|
380
|
-
type Infer<T, TT, D extends Field = any> = Modifier<T, Choose<T, TT, 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>>;
|
|
381
411
|
type Returns<T> = Field & {
|
|
382
412
|
get(value: any): T;
|
|
383
413
|
};
|
|
@@ -390,13 +420,6 @@ declare namespace Field {
|
|
|
390
420
|
type Updates<T> = T extends Accepts<infer U> ? (T extends Nullable ? U | null : U) | undefined : never;
|
|
391
421
|
type Assigns<T> = T extends Accepts<infer U> ? T extends Nullable ? U | null | undefined : T extends Optional ? U | undefined : U : never;
|
|
392
422
|
type Output = Record<string, string | number>;
|
|
393
|
-
type Compare<T> = {
|
|
394
|
-
is(value: Query.Value<T>): Cond;
|
|
395
|
-
not(value: Query.Value<T>): Cond;
|
|
396
|
-
over(value: Query.Value<T>, orEqual?: boolean): Cond;
|
|
397
|
-
under(value: Query.Value<T>, orEqual?: boolean): Cond;
|
|
398
|
-
in(value: Query.Value<T>[]): Cond;
|
|
399
|
-
};
|
|
400
423
|
const does: (callback: Callback) => void;
|
|
401
424
|
}
|
|
402
425
|
declare class Field<T = unknown> {
|
|
@@ -404,20 +427,20 @@ declare class Field<T = unknown> {
|
|
|
404
427
|
unique: boolean;
|
|
405
428
|
nullable: boolean;
|
|
406
429
|
optional: boolean;
|
|
430
|
+
absent: boolean;
|
|
407
431
|
increment: boolean;
|
|
408
432
|
fallback?: unknown;
|
|
433
|
+
column: string;
|
|
409
434
|
property: string;
|
|
410
|
-
parent: Type
|
|
411
|
-
table?: Query.
|
|
435
|
+
parent: Table.Type;
|
|
436
|
+
table?: Query.ITable;
|
|
412
437
|
query?: Builder;
|
|
413
438
|
/** If column has a reference constraint, applicable field is listed here. */
|
|
414
439
|
reference?: Field;
|
|
415
440
|
/** Real datatype of this field in database. */
|
|
416
441
|
get datatype(): string;
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
static new<T extends Field>(this: new (...args: any[]) => T, options?: Field.Opts<T>): Field;
|
|
420
|
-
create(property: string, parent: Type.EntityType): this;
|
|
442
|
+
static new<T extends Field>(this: new (...args: any[]) => T, ...options: Field.Args<T>): Field;
|
|
443
|
+
init?(property: string, parent: Table.Type): void;
|
|
421
444
|
/**
|
|
422
445
|
* Optional method generates value of property this Field is applied to when accessed inside a query.
|
|
423
446
|
* If not defined, the value will be the Field itself.
|
|
@@ -438,15 +461,8 @@ declare class Field<T = unknown> {
|
|
|
438
461
|
* a TINYINT(1) field to a boolean, or a DATETIME field to a Date object.
|
|
439
462
|
*/
|
|
440
463
|
get(value: any): T;
|
|
441
|
-
raw(value: T): string;
|
|
442
|
-
/**
|
|
443
|
-
* This method is used to compare this field with another value in a query.
|
|
444
|
-
*
|
|
445
|
-
* @param acc Set of comparisons to be added to if not part of a group.
|
|
446
|
-
*/
|
|
447
|
-
where(): Field.Compare<T>;
|
|
448
464
|
}
|
|
449
|
-
type Callback = (parent: Type
|
|
465
|
+
type Callback = (parent: Table.Type, property: string) => void;
|
|
450
466
|
|
|
451
467
|
declare class BooleanColumn extends Field<boolean> {
|
|
452
468
|
readonly type: Bool.DataType;
|
|
@@ -481,10 +497,10 @@ declare namespace Bool {
|
|
|
481
497
|
type DataType = keyof Types;
|
|
482
498
|
/** All available database types for Bool */
|
|
483
499
|
type Any = Types[keyof Types] | BooleanColumn;
|
|
484
|
-
type
|
|
500
|
+
type Options = Field.Args<Any>;
|
|
485
501
|
}
|
|
486
502
|
type Bool = Bool.Any;
|
|
487
|
-
declare function Bool<T extends 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,38 +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 Num.Opts>(opts
|
|
551
|
+
declare function Num<T extends Num.Opts>(...opts: T): Field.Infer<T, Num.Types, Num>;
|
|
536
552
|
declare namespace Num {
|
|
537
553
|
var Type: typeof NumericColumn;
|
|
538
554
|
}
|
|
539
555
|
|
|
540
|
-
declare class ForeignColumn<T extends
|
|
541
|
-
readonly entity: Type.EntityType<T>;
|
|
556
|
+
declare class ForeignColumn<T extends Table = Table> extends Field<Table.Values<T>> {
|
|
542
557
|
readonly type: One.DataType;
|
|
558
|
+
readonly entity: Table.Type<T>;
|
|
543
559
|
readonly nullable: boolean;
|
|
544
560
|
readonly onDelete?: string;
|
|
545
561
|
readonly onUpdate?: string;
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
use(query: Builder): any;
|
|
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
|
|
555
|
-
[K in keyof
|
|
556
|
-
}[
|
|
557
|
-
type Options = Omit<Partial<ForeignColumn<any>>, 'entity'>;
|
|
569
|
+
type Options = (null | string | {
|
|
570
|
+
[K in Exclude<keyof ForeignColumn, 'entity'>]?: ForeignColumn[K];
|
|
571
|
+
})[];
|
|
558
572
|
}
|
|
559
|
-
interface One<T extends
|
|
573
|
+
interface One<T extends Table> extends ForeignColumn<T> {
|
|
560
574
|
}
|
|
561
|
-
declare function One<T extends
|
|
562
|
-
declare function One<T extends Type>(entity: Type.EntityType<T>, nullable: boolean): One<T> & (boolean extends true ? Nullable : {});
|
|
563
|
-
declare function One<T extends Type, O extends One.Options>(entity: Type.EntityType<T>, options: O): Field.Infer<O, One.Types, One<T>> & ForeignColumn<T>;
|
|
575
|
+
declare function One<T extends Table, O extends One.Options>(entity: Table.Type<T>, ...options: O): Field.Mod<O, One<T>>;
|
|
564
576
|
declare namespace One {
|
|
565
577
|
var Type: typeof ForeignColumn;
|
|
566
578
|
}
|
|
@@ -602,10 +614,10 @@ declare namespace Str {
|
|
|
602
614
|
type DataType = keyof Types;
|
|
603
615
|
/** All available database types for Str */
|
|
604
616
|
type Any = Types[keyof Types] | StringColumn;
|
|
605
|
-
type Options =
|
|
617
|
+
type Options = Field.Args<Any>;
|
|
606
618
|
}
|
|
607
619
|
type Str = Str.Any;
|
|
608
|
-
declare function Str<T extends Str.Options>(opts
|
|
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,21 +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 Time.Options>(opts
|
|
663
|
+
declare function Time<T extends Time.Options>(...opts: T): Field.Infer<T, Time.Types, Time>;
|
|
652
664
|
declare namespace Time {
|
|
653
665
|
var Type: typeof TimeColumn;
|
|
654
666
|
}
|
|
655
667
|
|
|
656
|
-
declare
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
|
|
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>;
|
|
661
682
|
}
|
|
662
|
-
declare function
|
|
663
|
-
declare function Table(opts: Table.Options): Type.EntityType;
|
|
683
|
+
declare function Primary<A extends Primary.Options>(...opts: A): Field.Infer<A, {}, PrimaryColumn>;
|
|
664
684
|
|
|
665
|
-
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 };
|