@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.ts CHANGED
@@ -1,60 +1,75 @@
1
- declare namespace Type {
2
- type EntityType<T extends Type = Type> = (abstract new () => T) & typeof Type;
3
- type Fields<T extends Type, O extends Partial<Field> = never> = {
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 Type> = Fields<T, Nullable | Optional>;
7
- type NonNull<T extends Type> = Fields<T, Nullable>;
8
- type Insert<T extends Type> = {
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 Type> = {
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 Type, R> = (query: Query.From<T>, where: Query.Where) => R;
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 Type {
24
- this: Type.EntityType;
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: Primary;
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.EntityType;
37
- static insert<T extends Type>(this: Type.EntityType<T>, entries: Type.Insert<T> | Type.Insert<T>[]): Query<number>;
38
- static insert<T extends Type>(this: Type.EntityType<T>, number: number, map: (index: number) => Type.Insert<T>): Query<number>;
39
- static insert<T extends Type, I>(this: Type.EntityType<T>, forEach: Array<I>, map: (value: I, index: number) => Type.Insert<T>): Query<number>;
40
- static get<T extends Type>(this: Type.EntityType<T>, limit?: number): Query.Selects<T>;
41
- static get<T extends Type>(this: Type.EntityType<T>, where?: Type.Query<T, void>): Query.Selects<T>;
42
- static get<T extends Type, R>(this: Type.EntityType<T>, limit: number, where: Type.Query<T, R>): Query.Selects<R>;
43
- static one<T extends Type, R extends {}>(this: Type.EntityType<T>, query: Type.Query<T, R>): Promise<Query.Returns<R>>;
44
- static one<T extends Type>(this: Type.EntityType<T>, query?: Type.Query<T, void>): Promise<Type.Values<T>>;
45
- static one<T extends Type>(this: Type.EntityType<T>, id: number): Promise<Type.Values<T>>;
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.Value<string | number>;
57
- type Numeric = Query.Value<number>;
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.Value | Field<T> | Computed<T>;
79
- readonly right: Query.Value | Field<T> | Computed<T>;
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.Table): string | undefined;
97
- protected set(updates: Map<Query.Table, Builder.Insert>): string;
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 Type[] | {
112
- [key: string | number]: typeof Type;
126
+ type Types = typeof Table[] | {
127
+ [key: string | number]: typeof Table;
113
128
  };
114
129
  type Using = {
115
- [key: string | number]: typeof Type;
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 Type>>;
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.EntityType): Promise<boolean>;
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 Table = Builder.Table;
140
- type From<T extends Type = Type> = {
141
- [K in Type.Fields<T>]: T[K] extends Field.Queries<infer U> ? U : T[K];
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 Type = Type> = {
144
- [K in Type.Fields<T>]?: T[K] extends Field.Queries<infer U> ? U : T[K];
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 Type> = {
147
- [K in Type.Fields<T>]?: Updates<T[K]>;
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 Value<T = any> = T | Field<T> | Computed<T>;
153
- type Insert<T extends Type> = {
154
- [K in Type.Required<T>]: Field.Assigns<T[K]> | Field;
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 Type.Fields<T>]?: Field.Assigns<T[K]> | Field;
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: (Cond | Group)[]): Group;
188
+ (...orWhere: Expression[]): Group;
174
189
  /**
175
190
  * Declare inserts to be made into a given table.
176
191
  */
177
- <T extends Type>(entity: Type.EntityType<T>, ...inserts: Insert<T>[]): From<T>;
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 Type>(entity: Type.EntityType<T>): From<T>;
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 Type>(entity: Type.EntityType<T>, optional: true): Join<T>;
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 Type>(field: From<T> | Join<T>): Verbs<T>;
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 extends Field> = ReturnType<T["where"]>;
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: Query.Functions) => R;
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 Type.Fields<U>]: Returns<U[J]>;
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 Type> {
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 Table<T extends Type = any> {
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 Type> = (self: Query.From<T>, where: Query.Where) => void;
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.Table>;
280
- deletes: Set<Query.Table>;
281
- updates: Map<Query.Table, Builder.Insert>;
282
- inserts: Map<Query.Table, Builder.Insert>;
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<Type>;
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
- is(value: unknown): Cond;
293
- not(value: unknown): Cond;
294
- over(value: unknown, orEqual?: boolean): Cond;
295
- under(value: unknown, orEqual?: boolean): Cond;
296
- in(value: unknown[]): Cond;
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: (Cond | Group)[]): Group;
299
- use<T extends Type>(type: Type.EntityType<T>, optional?: false): Query.From<T>;
300
- use<T extends Type>(type: Type.EntityType<T>, optional: boolean): Query.Join<T>;
301
- use<T extends Type>(type: Type.EntityType<T>, ...inserts: Type.Insert<T>[]): Query.From<T>;
302
- insert<T extends Type>(table: Builder.Table<T>, input: Type.Insert<T>): void;
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): Cond | Group;
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.Table {
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<Cond | Group>;
350
- add(left: Field | Group | Cond, op?: string, right?: unknown): Cond | Group;
351
- delete(child: Cond | Group): void;
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 Opts<T extends Field = Field> = Partial<T>;
369
- type Modifier<T, TT> = T extends {
370
- nullable: true;
371
- } ? TT & Nullable : T extends {
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 Choose<T, TS, D extends Field = any> = T extends {
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.EntityType;
411
- table?: Query.Table;
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
- get column(): string;
418
- set column(value: string);
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.EntityType, property: string) => void;
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 Opts = Partial<Any>;
500
+ type Options = Field.Args<Any>;
485
501
  }
486
502
  type Bool = Bool.Any;
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,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 = Partial<Any>;
548
+ type Opts = Field.Args<Any>;
533
549
  }
534
550
  type Num = Num.Any;
535
- 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>;
536
552
  declare namespace Num {
537
553
  var Type: typeof NumericColumn;
538
554
  }
539
555
 
540
- declare class ForeignColumn<T extends Type = Type> extends Field<Type.Values<T>> {
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
- get column(): string;
547
- set(value: Type.Values<T> | number): any;
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 Any<T extends Type = Type> = {
555
- [K in keyof Types]: Types[K] extends ForeignColumn<any> ? Types[K] & ForeignColumn<T> : never;
556
- }[keyof Types] | ForeignColumn<T>;
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 Type> extends ForeignColumn<T> {
573
+ interface One<T extends Table> extends ForeignColumn<T> {
560
574
  }
561
- declare function One<T extends Type>(entity: Type.EntityType<T>): One<T>;
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 = Partial<Any>;
617
+ type Options = Field.Args<Any>;
606
618
  }
607
619
  type Str = Str.Any;
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,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 = Partial<Any>;
660
+ type Options = Field.Args<Any>;
649
661
  }
650
662
  type Time = Time.Any;
651
- 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>;
652
664
  declare namespace Time {
653
665
  var Type: typeof TimeColumn;
654
666
  }
655
667
 
656
- declare namespace Table {
657
- interface Options {
658
- table?: string;
659
- schema?: string;
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 Table(name: string, opts?: Table.Options): Type.EntityType;
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, Type };
685
+ export { Bool, Builder, Connection, DataTable, Field, Generator, type Nullable, Num, One, type Optional, Parameter, Primary, Query, Str, Table, Time };