orchid-orm 1.21.5 → 1.22.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.
Files changed (6) hide show
  1. package/dist/index.d.ts +128 -91
  2. package/dist/index.js +17 -17
  3. package/dist/index.js.map +1 -1
  4. package/dist/index.mjs +17 -17
  5. package/dist/index.mjs.map +1 -1
  6. package/package.json +6 -6
package/dist/index.d.ts CHANGED
@@ -1,50 +1,55 @@
1
- import { Query, SelectableFromShape, CreateMethodsNames, AddQueryDefaults, RelationConfigBase, SetQueryReturnsOne, SetQueryReturnsOneOptional, RelationJoinQuery, UpdateData, WhereArg, CreateData, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, RelationQueryBase, ComputedColumnsBase, MapTableScopesOption, QueryWithTable, QueryData, QueryBase, DbTableOptionScopes, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
1
+ import { Query, SelectableFromShape, CreateMethodsNames, AddQueryDefaults, RelationConfigBase, SetQueryReturnsOne, SetQueryReturnsOneOptional, RelationJoinQuery, UpdateData, WhereArg, CreateData, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, MapTableScopesOption, ComputedColumnsBase, QueryData, QueryBase, DbTableOptionScopes, DefaultSchemaConfig, DefaultColumnTypes, RelationQueryBase, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery } from 'pqb';
2
2
  export * from 'pqb';
3
- import { ColumnsShapeBase, EmptyObject, MaybeArray, StringKey, CoreQueryScopes, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput, ColumnSchemaConfig } from 'orchid-core';
3
+ import { ColumnsShapeBase, RecordKeyTrue, EmptyObject, MaybeArray, RecordUnknown, CoreQueryScopes, ColumnShapeOutput, ColumnShapeInput, ColumnShapeInputPartial, ColumnSchemaConfig, QueryReturnType } from 'orchid-core';
4
4
 
5
- type RelationCommonOptions<Related extends TableClass = TableClass, Scope extends Query = Query> = {
5
+ interface RelationCommonOptions<Related extends TableClass = TableClass, Scope extends Query = Query> {
6
6
  scope?: ScopeFn<Related, Scope>;
7
7
  required?: boolean;
8
- };
9
- type RelationRefsOptions<Column extends PropertyKey = string, Ref extends PropertyKey = string> = {
8
+ }
9
+ interface RelationRefsOptions<Column extends PropertyKey = string, Ref extends PropertyKey = string> {
10
10
  columns: Column[];
11
11
  references: Ref[];
12
- };
13
- type RelationKeysOptions<PK extends PropertyKey = string, FK extends PropertyKey = string> = {
12
+ }
13
+ interface RelationKeysOptions<PK extends PropertyKey = string, FK extends PropertyKey = string> {
14
14
  primaryKey: PK;
15
15
  foreignKey: FK;
16
- };
16
+ }
17
17
  type RelationRefsOrKeysOptions<Column extends PropertyKey = string, Ref extends PropertyKey = string, PK extends PropertyKey = string, FK extends PropertyKey = string> = RelationRefsOptions<Column, Ref> | RelationKeysOptions<PK, FK>;
18
- type RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> = {
18
+ interface RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> {
19
19
  through: Through;
20
20
  source: Source;
21
- };
21
+ }
22
22
  type RelationHasOptions<Column extends PropertyKey = string, Ref extends PropertyKey = string> = RelationRefsOrKeysOptions<Column, Ref, Column, Ref>;
23
23
 
24
- type HasOne = RelationThunkBase & {
24
+ interface HasOne extends RelationThunkBase {
25
25
  type: 'hasOne';
26
26
  options: HasOneOptions;
27
- };
27
+ }
28
28
  type HasOneOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = RelationCommonOptions<Related, Scope> & (RelationHasOptions<keyof Columns, keyof InstanceType<Related>['columns']> | RelationThroughOptions<Through, Source>);
29
- interface HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne, Name extends string, TableQuery extends Query, Populate extends Record<string, true> = Relation['options'] extends RelationRefsOptions ? Record<Relation['options']['references'][number], true> : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['foreignKey'], true> : never, Q extends Query = Relation['options'] extends RelationThroughOptions ? {
30
- [K in keyof TableQuery]: K extends 'meta' ? TableQuery['meta'] & {
29
+ type HasOneParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? {
30
+ [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
31
+ } : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Relation['options']['through']]> : never;
32
+ interface HasOneInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, Populate extends RecordKeyTrue = T['relations'][Name]['options'] extends RelationRefsOptions ? Record<T['relations'][Name]['options']['references'][number], true> : T['relations'][Name]['options'] extends RelationKeysOptions ? Record<T['relations'][Name]['options']['foreignKey'], true> : never, Q extends Query = T['relations'][Name]['options'] extends RelationThroughOptions ? {
33
+ [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
31
34
  as: Name;
32
35
  defaults: Populate;
33
36
  hasWhere: true;
34
- } : K extends 'selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends 'join' ? RelJoin : K extends CreateMethodsNames ? never : TableQuery[K];
37
+ selectable: SelectableFromShape<TableQuery['shape'], Name>;
38
+ } : K extends 'join' ? RelJoin : K extends CreateMethodsNames ? never : TableQuery[K];
35
39
  } : {
36
- [K in keyof TableQuery]: K extends 'meta' ? TableQuery['meta'] & {
40
+ [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
37
41
  as: Name;
38
42
  defaults: Populate;
39
43
  hasWhere: true;
40
- } : K extends 'selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends 'join' ? RelJoin : TableQuery[K];
41
- }, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> extends RelationConfigBase {
44
+ selectable: SelectableFromShape<TableQuery['shape'], Name>;
45
+ } : K extends 'join' ? RelJoin : TableQuery[K];
46
+ }, NestedCreateQuery extends Query = T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> extends RelationConfigBase {
42
47
  query: Q;
43
- methodQuery: Relation['options']['required'] extends true ? SetQueryReturnsOne<Q> : SetQueryReturnsOneOptional<Q>;
48
+ methodQuery: T['relations'][Name]['options']['required'] extends true ? SetQueryReturnsOne<Q> : SetQueryReturnsOneOptional<Q>;
44
49
  joinQuery: RelationJoinQuery;
45
50
  one: true;
46
51
  omitForeignKeyInCreate: never;
47
- optionalDataForCreate: Relation['options'] extends RelationThroughOptions ? EmptyObject : {
52
+ optionalDataForCreate: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : {
48
53
  [P in Name]?: RelationToOneDataForCreate<{
49
54
  nestedCreateQuery: NestedCreateQuery;
50
55
  table: Q;
@@ -67,37 +72,40 @@ interface HasOneInfo<T extends Table, Relations extends RelationThunks, Relation
67
72
  } | {
68
73
  create: CreateData<NestedCreateQuery>;
69
74
  };
70
- params: Relation['options'] extends RelationRefsOptions ? {
71
- [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
72
- } : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfig<T, Relations, Relations[Relation['options']['through']], Relation['options']['through']>['params'] : never;
75
+ params: HasOneParams<T, T['relations'][Name]>;
73
76
  }
74
77
 
75
- type HasMany = RelationThunkBase & {
78
+ interface HasMany extends RelationThunkBase {
76
79
  type: 'hasMany';
77
80
  options: HasManyOptions;
78
- };
81
+ }
79
82
  type HasManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = HasOneOptions<Columns, Related, Scope, Through, Source>;
80
- interface HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany, Name extends string, TableQuery extends Query, Populate extends Record<string, true> = Relation['options'] extends RelationRefsOptions ? Record<Relation['options']['references'][number], true> : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['foreignKey'], true> : never, Q extends Query = Relation['options'] extends RelationThroughOptions ? {
81
- [K in keyof TableQuery]: K extends 'meta' ? TableQuery['meta'] & {
83
+ type HasManyParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? {
84
+ [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
85
+ } : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Relation['options']['through']]> : never;
86
+ interface HasManyInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, Populate extends PropertyKey = T['relations'][Name]['options'] extends RelationRefsOptions ? T['relations'][Name]['options']['references'][number] : T['relations'][Name]['options'] extends RelationKeysOptions ? T['relations'][Name]['options']['foreignKey'] : never, Q extends Query = T['relations'][Name]['options'] extends RelationThroughOptions ? {
87
+ [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
82
88
  as: Name;
83
- defaults: Populate;
89
+ defaults: Record<Populate, true>;
84
90
  hasWhere: true;
85
- } : K extends 'selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends 'join' ? RelJoin : K extends CreateMethodsNames ? never : TableQuery[K];
91
+ selectable: SelectableFromShape<TableQuery['shape'], Name>;
92
+ } : K extends 'join' ? RelJoin : K extends CreateMethodsNames ? never : TableQuery[K];
86
93
  } : {
87
- [K in keyof TableQuery]: K extends 'meta' ? TableQuery['meta'] & {
94
+ [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
88
95
  as: Name;
89
- defaults: Populate;
96
+ defaults: Record<Populate, true>;
90
97
  hasWhere: true;
91
- } : K extends 'selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends 'join' ? RelJoin : TableQuery[K];
92
- }, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> extends RelationConfigBase {
98
+ selectable: SelectableFromShape<TableQuery['shape'], Name>;
99
+ } : K extends 'join' ? RelJoin : TableQuery[K];
100
+ }> extends RelationConfigBase {
93
101
  query: Q;
94
102
  methodQuery: Q;
95
103
  joinQuery: RelationJoinQuery;
96
104
  one: false;
97
105
  omitForeignKeyInCreate: never;
98
106
  optionalDataForCreate: {
99
- [P in Name]?: Relation['options'] extends RelationThroughOptions ? EmptyObject : RelationToManyDataForCreate<{
100
- nestedCreateQuery: NestedCreateQuery;
107
+ [P in Name]?: T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : RelationToManyDataForCreate<{
108
+ nestedCreateQuery: T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Record<Populate, true>>;
101
109
  table: Q;
102
110
  }>;
103
111
  };
@@ -111,25 +119,29 @@ interface HasManyInfo<T extends Table, Relations extends RelationThunks, Relatio
111
119
  };
112
120
  dataForUpdateOne: {
113
121
  set?: MaybeArray<WhereArg<Q>>;
114
- create?: CreateData<NestedCreateQuery>[];
122
+ create?: CreateData<T['relations'][Name]['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Record<Populate, true>>>[];
115
123
  };
116
- params: Relation['options'] extends RelationRefsOptions ? {
117
- [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
118
- } : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfig<T, Relations, Relations[Relation['options']['through']], Relation['options']['through']>['params'] : never;
124
+ params: HasManyParams<T, T['relations'][Name]>;
119
125
  }
120
126
 
121
- type RelJoin = <T extends Query>(this: T) => T;
127
+ type RelJoin = JoinQueryMethod & (<T extends Query>(this: T) => T);
122
128
 
123
- type BelongsTo = RelationThunkBase & {
129
+ interface BelongsTo extends RelationThunkBase {
124
130
  type: 'belongsTo';
125
131
  options: BelongsToOptions;
126
- };
132
+ }
127
133
  type BelongsToOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & RelationRefsOrKeysOptions<keyof Columns, keyof InstanceType<Related>['columns'], keyof InstanceType<Related>['columns'], keyof Columns>;
128
- interface BelongsToInfo<T extends Table, Relation extends BelongsTo, Name extends string, TableQuery extends Query, FK extends string = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never, Required = Relation['options']['required'] extends true ? true : false, Q extends Query = {
129
- [K in keyof TableQuery]: K extends 'meta' ? TableQuery['meta'] & {
134
+ type BelongsToFKey<Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never;
135
+ type BelongsToParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = {
136
+ [Name in BelongsToFKey<Relation>]: T['columns'][Name]['type'];
137
+ };
138
+ interface BelongsToInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, FK extends string = BelongsToFKey<T['relations'][Name]>, Required = T['relations'][Name]['options']['required'] extends true ? true : false, Q extends Query = {
139
+ [K in keyof TableQuery]: K extends 'meta' ? // Omit is optimal
140
+ Omit<TableQuery['meta'], 'selectable'> & {
130
141
  as: Name;
131
142
  hasWhere: true;
132
- } : K extends 'selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends 'join' ? RelJoin : K extends CreateMethodsNames | DeleteMethodsNames ? never : TableQuery[K];
143
+ selectable: SelectableFromShape<TableQuery['shape'], Name>;
144
+ } : K extends 'join' ? RelJoin : K extends CreateMethodsNames | DeleteMethodsNames ? never : TableQuery[K];
133
145
  }> extends RelationConfigBase {
134
146
  query: Q;
135
147
  methodQuery: Required extends true ? SetQueryReturnsOne<Q> : SetQueryReturnsOneOptional<Q>;
@@ -141,15 +153,9 @@ interface BelongsToInfo<T extends Table, Relation extends BelongsTo, Name extend
141
153
  [L in FK]: T['columns'][L]['inputType'];
142
154
  };
143
155
  nested: Required extends true ? {
144
- [Key in Name]: RelationToOneDataForCreate<{
145
- nestedCreateQuery: Q;
146
- table: Q;
147
- }>;
156
+ [Key in Name]: RelationToOneDataForCreateSameQuery<Q>;
148
157
  } : {
149
- [Key in Name]?: RelationToOneDataForCreate<{
150
- nestedCreateQuery: Q;
151
- table: Q;
152
- }>;
158
+ [Key in Name]?: RelationToOneDataForCreateSameQuery<Q>;
153
159
  };
154
160
  };
155
161
  optionalDataForCreate: EmptyObject;
@@ -170,9 +176,7 @@ interface BelongsToInfo<T extends Table, Relation extends BelongsTo, Name extend
170
176
  create: CreateData<Q> | (() => CreateData<Q>);
171
177
  };
172
178
  };
173
- params: {
174
- [Name in FK]: T['columns'][FK]['type'];
175
- };
179
+ params: BelongsToParams<T, T['relations'][Name]>;
176
180
  }
177
181
 
178
182
  declare function transaction<T extends {
@@ -183,7 +187,7 @@ declare function transaction<T extends {
183
187
  }, Result>(this: T, options: IsolationLevel | TransactionOptions, fn: () => Promise<Result>): Promise<Result>;
184
188
 
185
189
  type OrchidORM<T extends TableClasses = TableClasses> = {
186
- [K in keyof T]: DbTable<T[K]>;
190
+ [K in keyof T]: DbTable<InstanceType<T[K]>>;
187
191
  } & {
188
192
  $transaction: typeof transaction;
189
193
  $adapter: Adapter;
@@ -257,10 +261,10 @@ declare const orchidORM: <T extends TableClasses>({ log, logger, autoPreparedSta
257
261
  noPrimaryKey?: NoPrimaryKeyOption | undefined;
258
262
  }, tables: T) => OrchidORM<T>;
259
263
 
260
- type HasAndBelongsToMany = RelationThunkBase & {
264
+ interface HasAndBelongsToMany extends RelationThunkBase {
261
265
  type: 'hasAndBelongsToMany';
262
266
  options: HasAndBelongsToManyOptions;
263
- };
267
+ }
264
268
  type HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & ({
265
269
  columns: (keyof Columns)[];
266
270
  references: string[];
@@ -276,11 +280,19 @@ type HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeB
276
280
  associationPrimaryKey: string;
277
281
  associationForeignKey: keyof InstanceType<Related>['columns'];
278
282
  });
279
- interface HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany, Name extends string, TableQuery extends Query, Q extends Query = {
280
- [K in keyof TableQuery]: K extends 'meta' ? TableQuery['meta'] & {
283
+ type HasAndBelongsToManyParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends {
284
+ columns: string[];
285
+ } ? {
286
+ [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
287
+ } : Relation['options'] extends {
288
+ primaryKey: string;
289
+ } ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : never;
290
+ interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, Q extends Query = {
291
+ [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
281
292
  as: Name;
282
293
  hasWhere: true;
283
- } : K extends 'selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends 'join' ? RelJoin : TableQuery[K];
294
+ selectable: SelectableFromShape<TableQuery['shape'], Name>;
295
+ } : K extends 'join' ? RelJoin : TableQuery[K];
284
296
  }> extends RelationConfigBase {
285
297
  query: Q;
286
298
  methodQuery: Q;
@@ -304,13 +316,7 @@ interface HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelong
304
316
  create?: CreateData<Q>[];
305
317
  };
306
318
  dataForUpdateOne: EmptyObject;
307
- params: Relation['options'] extends {
308
- columns: string[];
309
- } ? {
310
- [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
311
- } : Relation['options'] extends {
312
- primaryKey: string;
313
- } ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : never;
319
+ params: HasAndBelongsToManyParams<T, T['relations'][Name]>;
314
320
  }
315
321
 
316
322
  type RelationToOneDataForCreate<Rel extends {
@@ -332,6 +338,22 @@ type RelationToOneDataForCreate<Rel extends {
332
338
  create: CreateData<Rel['nestedCreateQuery']>;
333
339
  };
334
340
  };
341
+ type RelationToOneDataForCreateSameQuery<Q extends Query> = {
342
+ create: CreateData<Q>;
343
+ connect?: never;
344
+ connectOrCreate?: never;
345
+ } | {
346
+ create?: never;
347
+ connect: WhereArg<Q>;
348
+ connectOrCreate?: never;
349
+ } | {
350
+ create?: never;
351
+ connect?: never;
352
+ connectOrCreate: {
353
+ where: WhereArg<Q>;
354
+ create: CreateData<Q>;
355
+ };
356
+ };
335
357
  type RelationToManyDataForCreate<Rel extends {
336
358
  nestedCreateQuery: Query;
337
359
  table: Query;
@@ -349,33 +371,44 @@ interface RelationThunkBase {
349
371
  options: RelationCommonOptions;
350
372
  }
351
373
  type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
352
- type RelationThunks = Record<string, RelationThunk>;
353
- type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : RelationQueryFromFn<Relation>;
354
- type RelationQueryFromFn<Relation extends RelationThunkBase, TC extends TableClass = ReturnType<Relation['fn']>, Q extends Query = DbTable<TC>> = Q;
355
- type RelationConfig<T extends Table = Table, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk, K extends PropertyKey = PropertyKey, TableQuery extends Query = Query, Result extends RelationConfigBase = Relation extends BelongsTo ? BelongsToInfo<T, Relation, StringKey<K>, TableQuery> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation, StringKey<K>, TableQuery> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation, StringKey<K>, TableQuery> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation, StringKey<K>, TableQuery> : never> = Result;
356
- type MapRelation<T extends Table, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], TableQuery extends Query = RelationScopeOrTable<Relation>> = RelationQuery<RelationConfig<T, Relations, Relation, RelationName, TableQuery>>;
357
- type MapRelations<T extends Table> = T extends {
374
+ interface RelationThunks {
375
+ [K: string]: RelationThunk;
376
+ }
377
+ type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbTable<InstanceType<ReturnType<Relation['fn']>>>;
378
+ interface RelationConfigSelf {
379
+ columns: ColumnsShapeBase;
380
+ relations: RelationThunks;
381
+ }
382
+ type RelationConfigParams<T extends RelationConfigSelf, Relation extends RelationThunk> = Relation extends BelongsTo ? BelongsToParams<T, Relation> : Relation extends HasOne ? HasOneParams<T, Relation> : Relation extends HasMany ? HasManyParams<T, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyParams<T, Relation> : never;
383
+ type MapRelation<T extends RelationConfigSelf, K extends keyof T['relations'] & string> = RelationQuery<T['relations'][K] extends BelongsTo ? BelongsToInfo<T, K, RelationScopeOrTable<T['relations'][K]>> : T['relations'][K] extends HasOne ? HasOneInfo<T, K, RelationScopeOrTable<T['relations'][K]>> : T['relations'][K] extends HasMany ? HasManyInfo<T, K, RelationScopeOrTable<T['relations'][K]>> : T['relations'][K] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, K, RelationScopeOrTable<T['relations'][K]>> : never>;
384
+ type MapRelations<T> = T extends {
385
+ columns: ColumnsShapeBase;
358
386
  relations: RelationThunks;
359
387
  } ? {
360
- [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
388
+ [K in keyof T['relations'] & string]: MapRelation<T, K>;
361
389
  } : EmptyObject;
362
390
 
363
- type TableClass<T extends Table = Table> = {
391
+ interface TableClass<T extends Table = Table> {
364
392
  new (): T;
365
393
  instance(): T;
366
- };
367
- type TableClasses = Record<string, TableClass>;
368
- type TableToDb<T extends Table, RelationQueries extends Record<string, RelationQueryBase>> = Db<T['table'], T['columns'], RelationQueries, T['types'], T['computed'] extends ComputedColumnsBase<never> ? T['columns'] & {
394
+ }
395
+ interface TableClasses {
396
+ [K: string]: TableClass;
397
+ }
398
+ interface RelationQueriesBase {
399
+ [K: string]: RelationQueryBase;
400
+ }
401
+ interface TableToDb<T extends Table, RelationQueries extends RelationQueriesBase> extends Db<T['table'], T['columns'], RelationQueries, T['types'], T['computed'] extends RecordUnknown ? T['columns'] & {
369
402
  [K in keyof T['computed']]: ReturnType<T['computed'][K]>['_type'];
370
- } : T['columns'], MapTableScopesOption<T['scopes'], T['softDelete']>> & {
403
+ } : T['columns'], MapTableScopesOption<T['scopes'], T['softDelete']>> {
371
404
  definedAs: string;
372
405
  db: OrchidORM;
373
406
  getFilePath(): string;
374
407
  name: string;
375
- };
376
- type DbTable<TC extends TableClass, T extends Table = InstanceType<TC>, RelationQueries extends Record<string, RelationQueryBase> = MapRelations<T>, Q extends QueryWithTable = TableToDb<T, RelationQueries>, Result extends QueryWithTable = Q & RelationQueries> = Result;
377
- type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<Related>) => Scope;
378
- type Table = {
408
+ }
409
+ type DbTable<T extends Table> = TableToDb<T, MapRelations<T>> & MapRelations<T>;
410
+ type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<InstanceType<Related>>) => Scope;
411
+ interface Table {
379
412
  table: string;
380
413
  columns: ColumnsShapeBase;
381
414
  schema?: string;
@@ -389,11 +422,13 @@ type Table = {
389
422
  computed?: ComputedColumnsBase<never>;
390
423
  scopes?: CoreQueryScopes;
391
424
  readonly softDelete?: true | string;
425
+ }
426
+ type Queryable<T extends Table> = {
427
+ [K in keyof T['columns']]?: T['columns'][K]['queryType'];
392
428
  };
393
- type Queryable<T extends Table> = Partial<ColumnShapeQueryType<T['columns']>>;
394
429
  type Selectable<T extends Table> = ColumnShapeOutput<T['columns']>;
395
430
  type Insertable<T extends Table> = ColumnShapeInput<T['columns']>;
396
- type Updateable<T extends Table> = Partial<Insertable<T>>;
431
+ type Updateable<T extends Table> = ColumnShapeInputPartial<T['columns']>;
397
432
  type BeforeHookMethod = <T extends Table>(cb: QueryBeforeHook) => T;
398
433
  type AfterHookMethod = <T extends Table>(cb: QueryAfterHook) => T;
399
434
  type AfterSelectableHookMethod = <T extends Table, S extends (keyof T['columns'])[]>(this: T, select: S, cb: AfterHook<S, T['columns']>) => T;
@@ -574,14 +609,16 @@ declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = Defau
574
609
  }): BaseTableClass<SchemaConfig, ColumnTypes>;
575
610
 
576
611
  type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;
577
- type QueryOne<T extends Query> = SetQueryReturns<T, Exclude<QueryReturnType, 'all'>>;
578
- type MethodsBase<T extends Query> = {
612
+ type QueryOne<T extends Query> = {
613
+ [K in keyof T]: K extends 'returnType' ? Exclude<QueryReturnType, 'all'> : T[K];
614
+ };
615
+ interface MethodsBase<T extends Query> {
579
616
  queryMethods?: QueryMethods<T>;
580
617
  queryOneMethods?: QueryMethods<QueryOne<T>>;
581
618
  queryWithWhereMethods?: QueryMethods<WhereResult<T>>;
582
619
  queryOneWithWhereMethods?: QueryMethods<QueryOne<WhereResult<T>>>;
583
- methods?: Record<string, unknown>;
584
- };
620
+ methods?: RecordUnknown;
621
+ }
585
622
  type MapQueryMethods<T extends Query, BaseQuery extends Query, Methods> = Methods extends QueryMethods<T> ? {
586
623
  [K in keyof Methods]: Methods[K] extends (q: any, ...args: infer Args) => infer Result ? <T extends BaseQuery>(this: T, ...args: Args) => Result extends Query ? MergeQuery<T, Result> : Result : never;
587
624
  } : EmptyObject;
package/dist/index.js CHANGED
@@ -229,7 +229,8 @@ const joinQueryChainingHOF = (reverseJoin, joinQuery) => (joiningQuery, baseQuer
229
229
  const inner = reverseJoin(query, joiningQuery);
230
230
  return joiningQuery.where({
231
231
  EXISTS: {
232
- args: [inner]
232
+ first: inner,
233
+ args: orchidCore.emptyArray
233
234
  }
234
235
  });
235
236
  };
@@ -360,7 +361,10 @@ const nestedInsert$3 = ({ query, primaryKeys }) => {
360
361
  for (let i = 0, len = items.length; i < len; i++) {
361
362
  items[i] = "create" in items[i] ? items[i].create : items[i].connectOrCreate.create;
362
363
  }
363
- created = await pqb._queryCreateMany(t.select(...primaryKeys), items);
364
+ created = await pqb._queryCreateMany(
365
+ t.select(...primaryKeys),
366
+ items
367
+ );
364
368
  } else {
365
369
  created = orchidCore.emptyArray;
366
370
  }
@@ -711,10 +715,7 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys }) => {
711
715
  ids
712
716
  );
713
717
  if (params.create || params.disconnect || params.set) {
714
- await pqb._queryUpdate(
715
- currentRelationsQuery,
716
- setNulls
717
- );
718
+ await pqb._queryUpdate(currentRelationsQuery, setNulls);
718
719
  const record = data[0];
719
720
  if (params.create) {
720
721
  const obj = __spreadValues$5({}, params.create);
@@ -734,10 +735,7 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys }) => {
734
735
  );
735
736
  }
736
737
  } else if (params.update) {
737
- await pqb._queryUpdate(
738
- currentRelationsQuery,
739
- params.update
740
- );
738
+ await pqb._queryUpdate(currentRelationsQuery, params.update);
741
739
  } else if (params.delete) {
742
740
  await pqb._queryDelete(currentRelationsQuery);
743
741
  } else if (params.upsert) {
@@ -958,10 +956,7 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
958
956
  obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
959
957
  }
960
958
  queries.push(
961
- pqb._queryUpdate(
962
- t.where(item.where),
963
- obj
964
- )
959
+ pqb._queryUpdate(t.where(item.where), obj)
965
960
  );
966
961
  }
967
962
  }
@@ -1516,7 +1511,9 @@ const nestedUpdate = (state) => {
1516
1511
  );
1517
1512
  }
1518
1513
  if (params.disconnect) {
1519
- await pqb._queryDelete(queryJoinTable(state, data, params.disconnect));
1514
+ await pqb._queryDelete(
1515
+ queryJoinTable(state, data, params.disconnect)
1516
+ );
1520
1517
  }
1521
1518
  if (params.delete) {
1522
1519
  const j = queryJoinTable(state, data, params.delete);
@@ -1538,7 +1535,9 @@ const nestedUpdate = (state) => {
1538
1535
  delete j.q[pqb.toSQLCacheKey];
1539
1536
  const idsRows = await pqb._queryRows(
1540
1537
  pqb._querySelect(
1541
- state.relatedTableQuery.where(conditionsToWhereArg(params.set)),
1538
+ state.relatedTableQuery.where(
1539
+ conditionsToWhereArg(params.set)
1540
+ ),
1542
1541
  state.throughPrimaryKeys
1543
1542
  )
1544
1543
  );
@@ -1731,7 +1730,8 @@ const makeRelationQuery = (table, relationName, data, q) => {
1731
1730
  query = pqb._queryWhere(pqb._queryAll(toTable), [
1732
1731
  {
1733
1732
  EXISTS: {
1734
- args: [data.reverseJoin(this, toTable)]
1733
+ first: data.reverseJoin(this, toTable),
1734
+ args: orchidCore.emptyArray
1735
1735
  }
1736
1736
  }
1737
1737
  ]);