@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.ts CHANGED
@@ -1,56 +1,71 @@
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
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.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
167
  type Match<T = any> = T | (T extends Field<infer U> ? Match<U> : Field<T> | Computed<T>);
153
- type Insert<T extends Type> = {
154
- [K in Type.Required<T>]: Field.Assigns<T[K]> | Field;
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;
@@ -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 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.
@@ -200,7 +215,7 @@ declare namespace Query {
200
215
  connection: Connection.Ready;
201
216
  };
202
217
  type Compare<T> = {
203
- is(value: Match<T>): Expression;
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 Type.Fields<U>]: Returns<U[J]>;
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 Type> {
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 Table<T extends Type = any> {
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 Type> = (self: Query.From<T>, where: Query.Where) => void;
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.Table>;
286
- deletes: Set<Query.Table>;
287
- updates: Map<Query.Table, Builder.Insert>;
288
- 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>;
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<Type>;
309
+ table(table: Query.From): Query.Verbs<Table>;
295
310
  compare<T extends Field>(field: T): {
296
- is: (right: unknown, orEqual?: boolean) => Expression;
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
- is: (right: unknown, orEqual?: boolean) => Expression;
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 Type>(type: Type.EntityType<T>, optional?: false): Query.From<T>;
313
- use<T extends Type>(type: Type.EntityType<T>, optional: boolean): Query.Join<T>;
314
- use<T extends Type>(type: Type.EntityType<T>, ...inserts: Type.Insert<T>[]): Query.From<T>;
315
- insert<T extends Type>(table: Builder.Table<T>, input: Type.Insert<T>): void;
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.Table {
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 Opts<T extends Field = Field> = Partial<T>;
383
- type Modifier<T, TT> = T extends {
384
- nullable: true;
385
- } | true ? 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 {
386
407
  fallback?: any;
387
408
  increment?: true;
388
- } ? TT & Optional : TT;
389
- type Type<T, A, D extends Field = any> = T extends {
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.EntityType;
419
- table?: Query.Table;
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?: Field.Opts<T> | boolean): Field;
426
- 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;
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.EntityType, property: string) => void;
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 Opts = Partial<Any>;
500
+ type Options = Field.Args<Any>;
484
501
  }
485
502
  type Bool = Bool.Any;
486
- declare function Bool<T extends boolean>(nullable: T): Field.Infer<T, Bool.Types, Bool>;
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 = Partial<Any>;
548
+ type Opts = Field.Args<Any>;
533
549
  }
534
550
  type Num = Num.Any;
535
- declare function Num<T extends boolean>(nullable: T): Field.Infer<T, Num.Types, Num>;
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 Type = Type> extends Field<Type.Values<T>> {
556
+ declare class ForeignColumn<T extends Table = Table> extends Field<Table.Values<T>> {
542
557
  readonly type: One.DataType;
543
- readonly entity: Type.EntityType<T>;
558
+ readonly entity: Table.Type<T>;
544
559
  readonly nullable: boolean;
545
560
  readonly onDelete?: string;
546
561
  readonly onUpdate?: 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 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 Type> extends ForeignColumn<T> {
573
+ interface One<T extends Table> extends ForeignColumn<T> {
559
574
  }
560
- declare function One<T extends Type>(entity: Type.EntityType<T>, nullable?: false): One<T>;
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 = Partial<Any>;
617
+ type Options = Field.Args<Any>;
605
618
  }
606
619
  type Str = Str.Any;
607
- declare function Str<T extends boolean>(nullable: T): Field.Infer<T, Str.Types, Str>;
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 = Partial<Any>;
660
+ type Options = Field.Args<Any>;
649
661
  }
650
662
  type Time = Time.Any;
651
- declare function Time<T extends boolean>(nullable: T): Field.Infer<T, Time.Types, Time>;
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 namespace Table {
658
- interface Options {
659
- table?: string;
660
- schema?: string;
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 Table(name: string, opts?: Table.Options): Type.EntityType;
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, Type };
685
+ export { Bool, Builder, Connection, DataTable, Field, Generator, type Nullable, Num, One, type Optional, Parameter, Primary, Query, Str, Table, Time };