orchid-orm 1.20.1 → 1.21.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 +46 -38
  2. package/dist/index.js +7 -3
  3. package/dist/index.js.map +1 -1
  4. package/dist/index.mjs +7 -3
  5. package/dist/index.mjs.map +1 -1
  6. package/package.json +5 -5
package/dist/index.d.ts CHANGED
@@ -1,6 +1,6 @@
1
- import { Query, QueryWithTable, SetQueryTableAlias, RelationJoinQuery, WhereArg, UpdateData, CreateData, AddQueryDefaults, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, RelationConfigBase, RelationQueryBase, ComputedColumnsBase, MapTableScopesOption, QueryData, QueryBase, DbTableOptionScopes, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
1
+ import { Query, CreateMethodsNames, DeleteMethodsNames, SetQueryReturnsOne, SetQueryReturnsOneOptional, RelationJoinQuery, WhereArg, UpdateData, CreateData, AddQueryDefaults, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, RelationConfigBase, RelationQueryBase, ComputedColumnsBase, MapTableScopesOption, QueryWithTable, QueryData, QueryBase, DbTableOptionScopes, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
2
2
  export * from 'pqb';
3
- import { ColumnsShapeBase, EmptyObject, MaybeArray, StringKey, CoreQueryScopes, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput, ColumnSchemaConfig } from 'orchid-core';
3
+ import { ColumnsShapeBase, StringKey, EmptyObject, MaybeArray, CoreQueryScopes, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput, ColumnSchemaConfig } from 'orchid-core';
4
4
 
5
5
  type RelationCommonOptions<Related extends TableClass = TableClass, Scope extends Query = Query> = {
6
6
  scope?: ScopeFn<Related, Scope>;
@@ -26,24 +26,29 @@ type BelongsTo = RelationThunkBase & {
26
26
  options: BelongsToOptions;
27
27
  };
28
28
  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>;
29
- type BelongsToInfo<T extends Table, Relation extends BelongsTo, K extends string, FK extends string = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never, Q extends QueryWithTable = SetQueryTableAlias<DbTable<ReturnType<Relation['fn']>>, K>, DataForCreate = RelationToOneDataForCreate<{
29
+ type 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 = {
30
+ [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'as' | 'defaults'> & {
31
+ as: StringKey<Name>;
32
+ defaults: TableQuery['meta']['defaults'];
33
+ hasWhere: true;
34
+ } : K extends 'join' ? <T extends Query>(this: T) => T : K extends CreateMethodsNames | DeleteMethodsNames ? never : K extends keyof TableQuery ? TableQuery[K] : never;
35
+ }, DataForCreate = RelationToOneDataForCreate<{
30
36
  nestedCreateQuery: Q;
31
37
  table: Q;
32
- }>, Required = Relation['options']['required'] extends true ? true : false> = {
33
- table: Q;
38
+ }>> = {
34
39
  query: Q;
40
+ methodQuery: Required extends true ? SetQueryReturnsOne<Q> : SetQueryReturnsOneOptional<Q>;
35
41
  joinQuery: RelationJoinQuery;
36
42
  one: true;
37
- required: Required;
38
43
  omitForeignKeyInCreate: FK;
39
44
  dataForCreate: {
40
45
  columns: {
41
46
  [L in FK]: T['columns'][L]['inputType'];
42
47
  };
43
48
  nested: Required extends true ? {
44
- [Key in K]: DataForCreate;
49
+ [Key in Name]: DataForCreate;
45
50
  } : {
46
- [Key in K]?: DataForCreate;
51
+ [Key in Name]?: DataForCreate;
47
52
  };
48
53
  };
49
54
  optionalDataForCreate: EmptyObject;
@@ -65,11 +70,8 @@ type BelongsToInfo<T extends Table, Relation extends BelongsTo, K extends string
65
70
  };
66
71
  };
67
72
  params: {
68
- [K in FK]: T['columns'][FK]['type'];
73
+ [Name in FK]: T['columns'][FK]['type'];
69
74
  };
70
- populate: EmptyObject;
71
- chainedCreate: false;
72
- chainedDelete: false;
73
75
  };
74
76
 
75
77
  type HasMany = RelationThunkBase & {
@@ -77,15 +79,20 @@ type HasMany = RelationThunkBase & {
77
79
  options: HasManyOptions;
78
80
  };
79
81
  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
- type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany, K extends string, 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, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> = {
81
- table: Q;
82
+ type 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 = {
83
+ [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'as' | 'defaults'> & {
84
+ as: StringKey<Name>;
85
+ defaults: TableQuery['meta']['defaults'] & Populate;
86
+ hasWhere: true;
87
+ } : K extends 'join' ? <TableQuery extends Query>(this: TableQuery) => TableQuery : K extends CreateMethodsNames ? Relation['options'] extends RelationThroughOptions ? never : TableQuery[K] : K extends DeleteMethodsNames ? TableQuery[K] : K extends keyof TableQuery ? TableQuery[K] : never;
88
+ }, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> = {
82
89
  query: Q;
90
+ methodQuery: Q;
83
91
  joinQuery: RelationJoinQuery;
84
92
  one: false;
85
- required: Relation['options']['required'] extends true ? true : false;
86
93
  omitForeignKeyInCreate: never;
87
94
  optionalDataForCreate: {
88
- [P in K]?: Relation['options'] extends RelationThroughOptions ? EmptyObject : RelationToManyDataForCreate<{
95
+ [P in Name]?: Relation['options'] extends RelationThroughOptions ? EmptyObject : RelationToManyDataForCreate<{
89
96
  nestedCreateQuery: NestedCreateQuery;
90
97
  table: Q;
91
98
  }>;
@@ -103,11 +110,8 @@ type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation ext
103
110
  create?: CreateData<NestedCreateQuery>[];
104
111
  };
105
112
  params: Relation['options'] extends RelationRefsOptions ? {
106
- [K in Relation['options']['columns'][number]]: T['columns'][K]['type'];
113
+ [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
107
114
  } : 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;
108
- populate: Populate;
109
- chainedCreate: Relation['options'] extends RelationThroughOptions ? false : true;
110
- chainedDelete: true;
111
115
  };
112
116
 
113
117
  type HasOne = RelationThunkBase & {
@@ -115,15 +119,20 @@ type HasOne = RelationThunkBase & {
115
119
  options: HasOneOptions;
116
120
  };
117
121
  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>);
118
- type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne, K extends string, 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, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> = {
119
- table: Q;
122
+ type 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 = {
123
+ [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'as' | 'defaults'> & {
124
+ as: StringKey<Name>;
125
+ defaults: TableQuery['meta']['defaults'] & Populate;
126
+ hasWhere: true;
127
+ } : K extends 'join' ? <T extends Query>(this: T) => T : K extends CreateMethodsNames ? Relation['options'] extends RelationThroughOptions ? never : TableQuery[K] : K extends DeleteMethodsNames ? TableQuery[K] : K extends keyof TableQuery ? TableQuery[K] : never;
128
+ }, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> = {
120
129
  query: Q;
130
+ methodQuery: Relation['options']['required'] extends true ? SetQueryReturnsOne<Q> : SetQueryReturnsOneOptional<Q>;
121
131
  joinQuery: RelationJoinQuery;
122
132
  one: true;
123
- required: Relation['options']['required'] extends true ? true : false;
124
133
  omitForeignKeyInCreate: never;
125
134
  optionalDataForCreate: Relation['options'] extends RelationThroughOptions ? EmptyObject : {
126
- [P in K]?: RelationToOneDataForCreate<{
135
+ [P in Name]?: RelationToOneDataForCreate<{
127
136
  nestedCreateQuery: NestedCreateQuery;
128
137
  table: Q;
129
138
  }>;
@@ -146,11 +155,8 @@ type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation exte
146
155
  create: CreateData<NestedCreateQuery>;
147
156
  };
148
157
  params: Relation['options'] extends RelationRefsOptions ? {
149
- [K in Relation['options']['columns'][number]]: T['columns'][K]['type'];
158
+ [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
150
159
  } : 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;
151
- populate: Populate;
152
- chainedCreate: Relation['options'] extends RelationThroughOptions ? false : true;
153
- chainedDelete: true;
154
160
  };
155
161
 
156
162
  declare function transaction<T extends {
@@ -254,15 +260,20 @@ type HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeB
254
260
  associationPrimaryKey: string;
255
261
  associationForeignKey: keyof InstanceType<Related>['columns'];
256
262
  });
257
- type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany, K extends string, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>> = {
258
- table: Q;
263
+ type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany, Name extends string, TableQuery extends Query, Q extends Query = {
264
+ [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'as' | 'defaults'> & {
265
+ as: StringKey<Name>;
266
+ defaults: TableQuery['meta']['defaults'];
267
+ hasWhere: true;
268
+ } : K extends 'join' ? <T extends Query>(this: T) => T : K extends CreateMethodsNames ? TableQuery[K] : K extends DeleteMethodsNames ? TableQuery[K] : K extends keyof TableQuery ? TableQuery[K] : never;
269
+ }> = {
259
270
  query: Q;
271
+ methodQuery: Q;
260
272
  joinQuery: RelationJoinQuery;
261
273
  one: false;
262
- required: Relation['options']['required'] extends true ? true : false;
263
274
  omitForeignKeyInCreate: never;
264
275
  optionalDataForCreate: {
265
- [P in K]?: RelationToManyDataForCreate<{
276
+ [P in Name]?: RelationToManyDataForCreate<{
266
277
  nestedCreateQuery: Q;
267
278
  table: Q;
268
279
  }>;
@@ -281,13 +292,10 @@ type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMa
281
292
  params: Relation['options'] extends {
282
293
  columns: string[];
283
294
  } ? {
284
- [K in Relation['options']['columns'][number]]: T['columns'][K]['type'];
295
+ [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
285
296
  } : Relation['options'] extends {
286
297
  primaryKey: string;
287
298
  } ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : never;
288
- populate: EmptyObject;
289
- chainedCreate: true;
290
- chainedDelete: true;
291
299
  };
292
300
 
293
301
  type RelationToOneDataForCreate<Rel extends {
@@ -329,8 +337,8 @@ type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
329
337
  type RelationThunks = Record<string, RelationThunk>;
330
338
  type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : RelationQueryFromFn<Relation>;
331
339
  type RelationQueryFromFn<Relation extends RelationThunkBase, TC extends TableClass = ReturnType<Relation['fn']>, Q extends Query = DbTable<TC>> = Q;
332
- type RelationConfig<T extends Table = Table, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk, K extends PropertyKey = PropertyKey, Result extends RelationConfigBase = Relation extends BelongsTo ? BelongsToInfo<T, Relation, StringKey<K>> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation, StringKey<K>> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation, StringKey<K>> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation, StringKey<K>> : never> = Result;
333
- type MapRelation<T extends Table, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName]> = RelationQuery<RelationName, RelationConfig<T, Relations, Relation, RelationName>, RelationScopeOrTable<Relation>>;
340
+ 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;
341
+ 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>>;
334
342
  type MapRelations<T extends Table> = T extends {
335
343
  relations: RelationThunks;
336
344
  } ? {
package/dist/index.js CHANGED
@@ -133,7 +133,7 @@ const getThroughRelation = (table, through) => {
133
133
  };
134
134
  const getSourceRelation = (throughRelation, source) => {
135
135
  var _a;
136
- return (_a = throughRelation.table.relations[source]) == null ? void 0 : _a.relationConfig;
136
+ return (_a = throughRelation.query.relations[source]) == null ? void 0 : _a.relationConfig;
137
137
  };
138
138
  const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKeys, nestedInsert) => {
139
139
  const value = item[key];
@@ -1345,7 +1345,9 @@ const nestedInsert = ({
1345
1345
  const queries = [];
1346
1346
  for (const [, { connect }] of items) {
1347
1347
  for (const item of connect) {
1348
- queries.push(pqb._queryFindBy(t.select(...throughPrimaryKeys), [item]));
1348
+ queries.push(
1349
+ pqb._queryFindBy(t.select(...throughPrimaryKeys), [item])
1350
+ );
1349
1351
  }
1350
1352
  }
1351
1353
  connected = await Promise.all(queries);
@@ -1364,7 +1366,9 @@ const nestedInsert = ({
1364
1366
  for (const [, { connectOrCreate }] of items) {
1365
1367
  for (const item of connectOrCreate) {
1366
1368
  queries.push(
1367
- pqb._queryFindByOptional(t.select(...throughPrimaryKeys), [item.where])
1369
+ pqb._queryFindByOptional(t.select(...throughPrimaryKeys), [
1370
+ item.where
1371
+ ])
1368
1372
  );
1369
1373
  }
1370
1374
  }