orchid-orm 1.25.2 → 1.26.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Query, SelectableFromShape, CreateMethodsNames, AddQueryDefaults, SetQueryReturnsOne, SetQueryReturnsOneOptional, RelationJoinQuery, UpdateData, WhereArg, CreateData, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArg, FromArgOptions, FromResult, AdapterOptions, DbSharedOptions, RelationQuery, MapTableScopesOption, ComputedColumnsBase, QueryData, QueryBase, DbTableOptionScopes, DefaultSchemaConfig, DefaultColumnTypes, RelationQueryBase, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery } from 'pqb';
+import { Query, SelectableFromShape, CreateMethodsNames, AddQueryDefaults, SetQueryReturnsOne, SetQueryReturnsOneOptional, RelationJoinQuery, UpdateData, WhereArg, CreateData, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArg, FromArgOptions, FromResult, AdapterOptions, DbSharedOptions, RelationQuery, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, MapTableScopesOption, TableDataItem, ComputedColumnsBase, QueryData, QueryBase, TableDataFn, DbTableOptionScopes, DefaultSchemaConfig, DefaultColumnTypes, RelationQueryBase, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery } from 'pqb';
 export * from 'pqb';
 import { ColumnsShapeBase, EmptyObject, MaybeArray, RecordUnknown, CoreQueryScopes, ColumnShapeOutput, ColumnShapeInput, ColumnShapeInputPartial, ColumnSchemaConfig, QueryReturnType } from 'orchid-core';
 export * from 'orchid-core';
@@ -26,10 +26,10 @@ interface HasOne extends RelationThunkBase {
     type: 'hasOne';
     options: HasOneOptions;
 }
-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>);
+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']['shape']> | RelationThroughOptions<Through, Source>);
 type HasOneParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? {
-    [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
-} : 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;
+    [Name in Relation['options']['columns'][number]]: T['columns']['shape'][Name]['type'];
+} : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Relation['options']['through']]> : never;
 interface HasOneInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, Populate = 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 ? {
     [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
         as: Name;
@@ -82,8 +82,8 @@ interface HasMany extends RelationThunkBase {
 }
 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>;
 type HasManyParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? {
-    [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
-} : 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;
+    [Name in Relation['options']['columns'][number]]: T['columns']['shape'][Name]['type'];
+} : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Relation['options']['through']]> : never;
 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 ? {
     [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
         as: Name;
@@ -131,10 +131,10 @@ interface BelongsTo extends RelationThunkBase {
     type: 'belongsTo';
     options: BelongsToOptions;
 }
-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>;
+type BelongsToOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & RelationRefsOrKeysOptions<keyof Columns, keyof InstanceType<Related>['columns']['shape'], keyof InstanceType<Related>['columns']['shape'], keyof Columns>;
 type BelongsToFKey<Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never;
 type BelongsToParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = {
-    [Name in BelongsToFKey<Relation>]: T['columns'][Name]['type'];
+    [Name in BelongsToFKey<Relation>]: T['columns']['shape'][Name]['type'];
 };
 interface BelongsToInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, FK extends string, Required, Q extends Query = {
     [P in keyof TableQuery]: P extends 'meta' ? // Omit is optimal
@@ -151,7 +151,7 @@ interface BelongsToInfo<T extends RelationConfigSelf, Name extends keyof T['rela
     omitForeignKeyInCreate: FK;
     dataForCreate: {
         columns: {
-            [L in FK]: T['columns'][L]['inputType'];
+            [L in FK]: T['columns']['shape'][L]['inputType'];
         };
         nested: Required extends true ? {
             [Key in Name]: RelationToOneDataForCreateSameQuery<Q>;
@@ -270,22 +270,22 @@ type HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeB
     through: {
         table: string;
         columns: string[];
-        references: (keyof InstanceType<Related>['columns'])[];
+        references: (keyof InstanceType<Related>['columns']['shape'])[];
     };
 } | {
     primaryKey: keyof Columns;
     foreignKey: string;
     joinTable: string;
     associationPrimaryKey: string;
-    associationForeignKey: keyof InstanceType<Related>['columns'];
+    associationForeignKey: keyof InstanceType<Related>['columns']['shape'];
 });
 type HasAndBelongsToManyParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends {
     columns: string[];
 } ? {
-    [Name in Relation['options']['columns'][number]]: T['columns'][Name]['type'];
+    [Name in Relation['options']['columns'][number]]: T['columns']['shape'][Name]['type'];
 } : Relation['options'] extends {
     primaryKey: string;
-} ? Record<Relation['options']['primaryKey'], T['columns'][Relation['options']['primaryKey']]['type']> : never;
+} ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : never;
 interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends keyof T['relations'] & string, TableQuery extends Query, Q extends Query = {
     [K in keyof TableQuery]: K extends 'meta' ? Omit<TableQuery['meta'], 'selectable'> & {
         as: Name;
@@ -375,15 +375,14 @@ interface RelationThunks {
 }
 type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbTable<InstanceType<ReturnType<Relation['fn']>>>;
 interface RelationConfigSelf {
-    columns: ColumnsShapeBase;
+    columns: {
+        shape: ColumnsShapeBase;
+    };
     relations: RelationThunks;
 }
 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;
 type MapRelation<T extends RelationConfigSelf, K extends keyof T['relations'] & string> = RelationQuery<T['relations'][K] extends BelongsTo ? BelongsToInfo<T, K, RelationScopeOrTable<T['relations'][K]>, BelongsToFKey<T['relations'][K]>, T['relations'][K]['options']['required']> : 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>;
-type MapRelations<T> = T extends {
-    columns: ColumnsShapeBase;
-    relations: RelationThunks;
-} ? {
+type MapRelations<T> = T extends RelationConfigSelf ? {
     [K in keyof T['relations'] & string]: MapRelation<T, K>;
 } : EmptyObject;
 
@@ -397,9 +396,9 @@ interface TableClasses {
 interface RelationQueriesBase {
     [K: string]: RelationQueryBase;
 }
-interface TableToDb<T extends Table, RelationQueries extends RelationQueriesBase> extends Db<T['table'], T['columns'], RelationQueries, T['types'], T['computed'] extends RecordUnknown ? T['columns'] & {
+interface TableToDb<T extends Table, RelationQueries extends RelationQueriesBase> extends Db<T['table'], T['columns']['shape'], keyof ShapeColumnPrimaryKeys<T['columns']['shape']> extends never ? never : ShapeColumnPrimaryKeys<T['columns']['shape']>, ShapeUniqueColumns<T['columns']['shape']> | TableDataItemsUniqueColumns<T['columns']['shape'], T['columns']['data']>, TableDataItemsUniqueColumnTuples<T['columns']['shape'], T['columns']['data']>, UniqueConstraints<T['columns']['shape']> | TableDataItemsUniqueConstraints<T['columns']['data']>, RelationQueries, T['types'], T['computed'] extends RecordUnknown ? T['columns']['shape'] & {
     [K in keyof T['computed']]: ReturnType<T['computed'][K]>['_type'];
-} : T['columns'], MapTableScopesOption<T['scopes'], T['softDelete']>> {
+} : T['columns']['shape'], MapTableScopesOption<T['scopes'], T['softDelete']>> {
     definedAs: string;
     db: OrchidORM;
     getFilePath(): string;
@@ -409,7 +408,10 @@ type DbTable<T extends Table> = TableToDb<T, MapRelations<T>> & MapRelations<T>;
 type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<InstanceType<Related>>) => Scope;
 interface Table {
     table: string;
-    columns: ColumnsShapeBase;
+    columns: {
+        shape: ColumnsShapeBase;
+        data: MaybeArray<TableDataItem>;
+    };
     schema?: string;
     types: unknown;
     noPrimaryKey?: boolean;
@@ -424,17 +426,24 @@ interface Table {
     comment?: string;
 }
 type Queryable<T extends Table> = {
-    [K in keyof T['columns']]?: T['columns'][K]['queryType'];
+    [K in keyof T['columns']['shape']]?: T['columns']['shape'][K]['queryType'];
 };
-type Selectable<T extends Table> = ColumnShapeOutput<T['columns']>;
-type Insertable<T extends Table> = ColumnShapeInput<T['columns']>;
-type Updatable<T extends Table> = ColumnShapeInputPartial<T['columns']>;
+type Selectable<T extends Table> = ColumnShapeOutput<T['columns']['shape']>;
+type Insertable<T extends Table> = ColumnShapeInput<T['columns']['shape']>;
+type Updatable<T extends Table> = ColumnShapeInputPartial<T['columns']['shape']>;
 type BeforeHookMethod = <T extends Table>(cb: QueryBeforeHook) => T;
 type AfterHookMethod = <T extends Table>(cb: QueryAfterHook) => T;
-type AfterSelectableHookMethod = <T extends Table, S extends (keyof T['columns'])[]>(this: T, select: S, cb: AfterHook<S, T['columns']>) => T;
+type AfterSelectableHookMethod = <T extends Table, S extends (keyof T['columns']['shape'])[]>(this: T, select: S, cb: AfterHook<S, T['columns']['shape']>) => T;
+interface SetColumnsResult<Shape extends ColumnsShapeBase, Data extends MaybeArray<MaybeArray<TableDataItem>>> {
+    shape: Shape;
+    data: Data extends unknown[] ? Data : [Data];
+}
 interface BaseTableInstance<ColumnTypes> {
     table: string;
-    columns: ColumnsShapeBase;
+    columns: {
+        shape: ColumnsShapeBase;
+        data: MaybeArray<TableDataItem>;
+    };
     schema?: string;
     noPrimaryKey?: boolean;
     snakeCase?: boolean;
@@ -445,7 +454,7 @@ interface BaseTableInstance<ColumnTypes> {
     result: ColumnsShapeBase;
     clone<T extends QueryBase>(this: T): T;
     getFilePath(): string;
-    setColumns<T extends ColumnsShapeBase>(fn: (t: ColumnTypes) => T): T;
+    setColumns<Shape extends ColumnsShapeBase, Data extends MaybeArray<TableDataItem>>(fn: (t: ColumnTypes) => Shape, tableData?: TableDataFn<Shape, Data>): SetColumnsResult<Shape, Data>;
     /**
      * You can add a generated column in the migration (see [generated](/guide/migration-column-methods.html#generated-column)),
      * such column will persist in the database, it can be indexed.
@@ -536,37 +545,47 @@ interface BaseTableInstance<ColumnTypes> {
      *
      * @param computed - object where keys are column names and values are functions returning raw SQL
      */
-    setComputed<Table extends string, Shape extends ColumnsShapeBase, Computed extends ComputedColumnsBase<Db<Table, Shape, EmptyObject, ColumnTypes>>>(computed: Computed): Computed;
+    setComputed<Table extends string, Shape extends ColumnsShapeBase, Computed extends ComputedColumnsBase<Db<Table, Shape, never, never, never, never, EmptyObject, ColumnTypes>>>(computed: Computed): Computed;
     /**
      * See {@link ScopeMethods}
      */
     setScopes<Table extends string, Columns extends ColumnsShapeBase, Keys extends string>(this: {
         table: Table;
-        columns: Columns;
+        columns: {
+            shape: Columns;
+        };
     }, scopes: DbTableOptionScopes<Table, Columns, Keys>): CoreQueryScopes<Keys>;
     belongsTo<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Options extends BelongsToOptions<Columns, Related, Scope>>(this: {
-        columns: Columns;
+        columns: {
+            shape: Columns;
+        };
     }, fn: () => Related, options: Options): {
         type: 'belongsTo';
         fn: () => Related;
         options: Options;
     };
     hasOne<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Scope, Through, Source>>(this: {
-        columns: Columns;
+        columns: {
+            shape: Columns;
+        };
     }, fn: () => Related, options: Options): {
         type: 'hasOne';
         fn: () => Related;
         options: Options;
     };
     hasMany<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasManyOptions<Columns, Related, Scope, Through, Source>>(this: {
-        columns: Columns;
+        columns: {
+            shape: Columns;
+        };
     }, fn: () => Related, options: Options): {
         type: 'hasMany';
         fn: () => Related;
         options: Options;
     };
     hasAndBelongsToMany<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Options extends HasAndBelongsToManyOptions<Columns, Related, Scope>>(this: {
-        columns: Columns;
+        columns: {
+            shape: Columns;
+        };
     }, fn: () => Related, options: Options): {
         type: 'hasAndBelongsToMany';
         fn: () => Related;
@@ -629,4 +648,4 @@ type Repo<T extends Query, Methods extends MethodsBase<T>> = (<Q extends {
 }>(q: Q) => Query & Q & MapMethods<T, Methods>) & T & MapMethods<T, Methods>;
 declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(table: T, methods: Methods) => Repo<T, Methods>;
 
-export { BaseTableClass, BaseTableInstance, DbTable, Insertable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, Queryable, Repo, ScopeFn, Selectable, Table, TableClass, TableClasses, TableToDb, Updatable, createBaseTable, createRepo, orchidORM };
+export { BaseTableClass, BaseTableInstance, DbTable, Insertable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, Queryable, Repo, ScopeFn, Selectable, SetColumnsResult, Table, TableClass, TableClasses, TableToDb, Updatable, createBaseTable, createRepo, orchidORM };

package/dist/index.js

@@ -14,29 +14,39 @@ function createBaseTable({
   language
 } = {}) {
   var _a;
-  const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg(pqb.makeColumnTypes(schemaConfig)) : columnTypesArg || pqb.makeColumnTypes(pqb.defaultSchemaConfig);
+  const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg(pqb.makeColumnTypes(schemaConfig)) : columnTypesArg || pqb.makeColumnTypes(schemaConfig);
   const filePathOrStack = filePathArg || orchidCore.getStackTrace();
   let filePath;
+  const defaultColumns = {
+    shape: orchidCore.emptyObject,
+    data: orchidCore.emptyArray
+  };
   const base = (_a = class {
     constructor() {
+      this.columns = defaultColumns;
       this.snakeCase = snakeCase;
       this.types = columnTypes;
       this.q = {};
       this.language = language;
     }
     static inputSchema() {
+      this.instance();
       return this._inputSchema === void 0 ? this._inputSchema = schemaConfig.inputSchema.call(this) : this._inputSchema;
     }
     static outputSchema() {
+      this.instance();
       return this._outputSchema === void 0 ? this._outputSchema = schemaConfig.outputSchema.call(this) : this._outputSchema;
     }
     static querySchema() {
+      this.instance();
       return this._querySchema === void 0 ? this._querySchema = schemaConfig.querySchema.call(this) : this._querySchema;
     }
     static updateSchema() {
+      this.instance();
       return this._updateSchema === void 0 ? this._updateSchema = schemaConfig.updateSchema.call(this) : this._updateSchema;
     }
     static pkeySchema() {
+      this.instance();
       return this._pkeySchema === void 0 ? this._pkeySchema = schemaConfig.pkeySchema.call(this) : this._pkeySchema;
     }
     static getFilePath() {
@@ -71,10 +81,10 @@ function createBaseTable({
         `Failed to determine file path for table ${this.constructor.name}. Please set \`filePath\` property manually`
       );
     }
-    setColumns(fn) {
+    setColumns(fn, dataFn) {
       columnTypes[orchidCore.snakeCaseKey] = this.snakeCase;
       const shape = pqb.getColumnTypes(columnTypes, fn, nowSQL, this.language);
-      this.constructor.prototype.tableData = pqb.getTableData();
+      const tableData = this.constructor.prototype.tableData = pqb.parseTableData(dataFn);
       if (this.snakeCase) {
         for (const key in shape) {
           const column = shape[key];
@@ -86,7 +96,10 @@ function createBaseTable({
           }
         }
       }
-      return this.constructor.prototype.columns = shape;
+      return this.constructor.prototype.columns = {
+        shape,
+        data: tableData
+      };
     }
     setComputed(computed) {
       return computed;
@@ -169,7 +182,7 @@ const hasRelationHandleUpdate = (q, set, key, primaryKeys, nestedUpdate) => {
     return;
   selectIfNotSelected(q, primaryKeys);
   q.q.wrapInTransaction = true;
-  pqb._queryHookAfterUpdate(q, q.primaryKeys, (rows, q2) => {
+  pqb._queryHookAfterUpdate(q, primaryKeys, (rows, q2) => {
     return nestedUpdate(
       q2,
       rows,
@@ -443,7 +456,6 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
     }
     if (upsert) {
       ((_a = state.queries) != null ? _a : state.queries = []).push(async (queryResult) => {
-        var _a2;
         const row = queryResult.rows[0];
         let obj = {};
         for (let i = 0; i < len; i++) {
@@ -462,8 +474,13 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
         } else {
           const data = typeof upsert.create === "function" ? upsert.create() : upsert.create;
           const result = await pqb._queryCreate(query.select(...primaryKeys), data);
+          const collectData = {};
+          state.collect = {
+            keys: primaryKeys,
+            data: collectData
+          };
           for (let i = 0; i < len; i++) {
-            ((_a2 = state.updateData) != null ? _a2 : state.updateData = {})[foreignKeys[i]] = result[primaryKeys[i]];
+            collectData[foreignKeys[i]] = result[primaryKeys[i]];
           }
         }
       });
@@ -1871,11 +1888,11 @@ const orchidORM = (_a, tables) => {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       qb,
       table.table,
-      table.columns,
+      table.columns.shape,
       table.types,
       transactionStorage,
       options2,
-      (_a2 = table.constructor.prototype.tableData) != null ? _a2 : {}
+      (_a2 = table.constructor.prototype.tableData) != null ? _a2 : orchidCore.emptyObject
     );
     dbTable.definedAs = key;
     dbTable.db = result;