orchid-orm 1.58.10 → 1.59.1

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { ColumnsShapeBase, TableData, ColumnShapeInputPartial, Query, SelectableFromShape, CreateManyMethodsNames, CreateData, AddQueryDefaults, RelationConfigBase, QueryTake, QueryTakeOptional, EmptyObject, UpdateData, WhereArg, CreateMethodsNames, MaybeArray, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, AfterCommitStandaloneHook, AdapterBase, FromArg, FromResult, DbSharedOptions, RelationsBase, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, RecordUnknown, ShallowSimplify, ColumnShapeOutput, DefaultSelectColumns, ComputedOptionsConfig, QueryOrExpression, QueryColumn, ColumnShapeInput, QueryData, IsQuery, TableDataFn, DbTableOptionScopes, CoreQueryScopes, ColumnSchemaConfig, StaticSQLArgs, RawSQL, DynamicSQLArg, DynamicRawSQL, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHookInternal, QueryAfterHook, QueryColumns, AfterHook, WhereResult, MergeQuery, QueryReturnType } from 'pqb';
+import { Column, TableData, ColumnsShape, Query, SelectableFromShape, CreateManyMethodsNames, CreateData, AddQueryDefaults, RelationConfigBase, QueryTake, QueryTakeOptional, EmptyObject, UpdateData, WhereArg, CreateMethodsNames, MaybeArray, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, AfterCommitStandaloneHook, AdapterBase, FromArg, FromResult, DbSharedOptions, RelationsBase, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, RecordUnknown, ShallowSimplify, ComputedOptionsConfig, QueryOrExpression, QueryData, IsQuery, TableDataFn, DbTableOptionScopes, QueryScopes, ColumnSchemaConfig, StaticSQLArgs, RawSQL, DynamicSQLArg, DynamicRawSQL, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHookInternal, QueryAfterHook, AfterHook, WhereResult, MergeQuery, QueryReturnType } from 'pqb';
 export * from 'pqb';
 
-interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends ColumnsShapeBase = ColumnsShapeBase> {
+interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends Column.Shape.QueryInit = Column.Shape.QueryInit> {
     required?: boolean;
     columns: Column[];
     references: (keyof Shape)[];
     foreignKey?: boolean | TableData.References.Options;
-    on?: ColumnShapeInputPartial<Shape>;
+    on?: ColumnsShape.InputPartial<Shape>;
 }
 interface RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> {
     through: Through;
@@ -20,7 +20,7 @@ interface HasOne extends RelationThunkBase {
 interface RelationHasOneThroughOptions<Through extends string, Source extends string> extends RelationThroughOptions<Through, Source> {
     required?: boolean;
 }
-type HasOneOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Through extends string = string, Source extends string = string> = RelationRefsOptions<keyof Columns, InstanceType<Related>['columns']['shape']> | RelationHasOneThroughOptions<Through, Source>;
+type HasOneOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends TableClass = TableClass, Through extends string = string, Source extends string = string> = RelationRefsOptions<keyof Columns, InstanceType<Related>['columns']['shape']> | RelationHasOneThroughOptions<Through, Source>;
 type HasOneParams<T extends RelationConfigSelf, Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? {
     [Name in Relation['options']['columns'][number]]: T['columns']['shape'][Name]['type'];
 } : Relation['options'] extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Relation['options']['through']]> : never;
@@ -137,12 +137,12 @@ interface BelongsTo extends RelationThunkBase {
     type: 'belongsTo';
     options: BelongsToOptions;
 }
-interface BelongsToOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass> {
+interface BelongsToOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends TableClass = TableClass> {
     required?: boolean;
     columns: (keyof Columns)[];
     references: (keyof InstanceType<Related>['columns']['shape'])[];
     foreignKey?: boolean | TableData.References.Options;
-    on?: ColumnShapeInputPartial<InstanceType<Related>['columns']['shape']>;
+    on?: ColumnsShape.InputPartial<InstanceType<Related>['columns']['shape']>;
 }
 type BelongsToFKey<Relation extends RelationThunkBase> = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : never;
 type BelongsToParams<T extends RelationConfigSelf, Relation extends BelongsTo> = {
@@ -314,7 +314,7 @@ interface HasAndBelongsToMany extends RelationThunkBase {
     type: 'hasAndBelongsToMany';
     options: HasAndBelongsToManyOptions;
 }
-interface HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass> {
+interface HasAndBelongsToManyOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends TableClass = TableClass> {
     required?: boolean;
     columns: (keyof Columns)[];
     references: string[];
@@ -325,7 +325,7 @@ interface HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsS
         references: (keyof InstanceType<Related>['columns']['shape'])[];
         foreignKey?: boolean | TableData.References.Options;
     };
-    on?: ColumnShapeInputPartial<InstanceType<Related>['columns']['shape']>;
+    on?: ColumnsShape.InputPartial<InstanceType<Related>['columns']['shape']>;
 }
 type HasAndBelongsToManyParams<T extends RelationConfigSelf, Relation extends HasAndBelongsToMany> = {
     [Name in Relation['options']['columns'][number]]: T['columns']['shape'][Name]['type'];
@@ -425,7 +425,7 @@ interface RelationThunks {
 type RelationTableToQuery<Relation extends RelationThunkBase> = ORMTableInputToQueryBuilder<InstanceType<ReturnType<Relation['fn']>>>;
 interface RelationConfigSelf {
     columns: {
-        shape: ColumnsShapeBase;
+        shape: Column.Shape.QueryInit;
     };
     relations: RelationThunks;
 }
@@ -455,7 +455,7 @@ type ORMTableInputToQueryBuilder<T extends ORMTableInput> = T extends RelationCo
 interface ORMTableInput {
     table: string;
     columns: {
-        shape: ColumnsShapeBase;
+        shape: Column.Shape.QueryInit;
         data: MaybeArray<TableDataItem>;
     };
     schema?: string;
@@ -475,31 +475,31 @@ interface ORMTableInput {
 type Queryable<T extends ORMTableInput> = ShallowSimplify<{
     [K in keyof T['columns']['shape']]?: T['columns']['shape'][K]['queryType'];
 }>;
-type DefaultSelect<T extends ORMTableInput> = ShallowSimplify<Pick<ColumnShapeOutput<T['columns']['shape']>, DefaultSelectColumns<T['columns']['shape']>>>;
-type Selectable<T extends ORMTableInput> = T['computed'] extends ((t: never) => infer R extends ComputedOptionsConfig) ? ShallowSimplify<ColumnShapeOutput<T['columns']['shape']> & {
+type DefaultSelect<T extends ORMTableInput> = ShallowSimplify<ColumnsShape.DefaultOutput<T['columns']['shape']>>;
+type Selectable<T extends ORMTableInput> = T['computed'] extends ((t: never) => infer R extends ComputedOptionsConfig) ? ShallowSimplify<ColumnsShape.Output<T['columns']['shape']> & {
     [K in keyof R]: R[K] extends QueryOrExpression<unknown> ? R[K]['result']['value']['outputType'] : R[K] extends () => {
         result: {
-            value: infer Value extends QueryColumn;
+            value: infer Value extends Column.Pick.QueryColumn;
         };
     } ? Value['outputType'] : never;
-}> : ShallowSimplify<ColumnShapeOutput<T['columns']['shape']>>;
-type Insertable<T extends ORMTableInput> = ShallowSimplify<ColumnShapeInput<T['columns']['shape']>>;
-type Updatable<T extends ORMTableInput> = ShallowSimplify<ColumnShapeInputPartial<T['columns']['shape']>>;
+}> : ShallowSimplify<ColumnsShape.Output<T['columns']['shape']>>;
+type Insertable<T extends ORMTableInput> = ShallowSimplify<ColumnsShape.Input<T['columns']['shape']>>;
+type Updatable<T extends ORMTableInput> = ShallowSimplify<ColumnsShape.InputPartial<T['columns']['shape']>>;
 type BeforeHookMethod = (cb: QueryBeforeHookInternal) => void;
 type AfterHookMethod = (cb: QueryAfterHook) => void;
-type AfterSelectableHookMethod = <Shape extends QueryColumns, S extends (keyof Shape)[]>(this: {
+type AfterSelectableHookMethod = <Shape extends Column.QueryColumns, S extends (keyof Shape)[]>(this: {
     columns: {
         shape: Shape;
     };
 }, select: S, cb: AfterHook<S, Shape>) => void;
-interface SetColumnsResult<Shape extends ColumnsShapeBase, Data extends MaybeArray<MaybeArray<TableDataItem>>> {
+interface SetColumnsResult<Shape extends Column.Shape.QueryInit, Data extends MaybeArray<MaybeArray<TableDataItem>>> {
     shape: Shape;
     data: Data extends unknown[] ? Data : [Data];
 }
 interface BaseTableInstance<ColumnTypes> {
     table: string;
     columns: {
-        shape: ColumnsShapeBase;
+        shape: Column.Shape.QueryInit;
         data: MaybeArray<TableDataItem>;
     };
     schema?: string;
@@ -509,10 +509,10 @@ interface BaseTableInstance<ColumnTypes> {
     q: QueryData;
     language?: string;
     filePath: string;
-    result: ColumnsShapeBase;
+    result: Column.Shape.QueryInit;
     clone<T extends IsQuery>(this: T): T;
     getFilePath(): string;
-    setColumns<Shape extends ColumnsShapeBase, Data extends MaybeArray<TableDataItem>>(fn: (t: ColumnTypes) => Shape, tableData?: TableDataFn<Shape, Data>): SetColumnsResult<Shape, Data>;
+    setColumns<Shape extends Column.Shape.QueryInit, 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.
@@ -603,7 +603,7 @@ interface BaseTableInstance<ColumnTypes> {
      *
      * @param computed - object where keys are column names and values are functions returning raw SQL
      */
-    setComputed<Shape extends ColumnsShapeBase, Computed extends ComputedOptionsFactory<ColumnTypes, Shape>>(this: {
+    setComputed<Shape extends Column.Shape.QueryInit, Computed extends ComputedOptionsFactory<ColumnTypes, Shape>>(this: {
         columns: {
             shape: Shape;
         };
@@ -611,13 +611,13 @@ interface BaseTableInstance<ColumnTypes> {
     /**
      * See {@link ScopeMethods}
      */
-    setScopes<Table extends string, Shape extends ColumnsShapeBase, Keys extends string>(this: {
+    setScopes<Table extends string, Shape extends Column.Shape.QueryInit, Keys extends string>(this: {
         table: Table;
         columns: {
             shape: Shape;
         };
-    }, scopes: DbTableOptionScopes<Table, Shape, Keys>): CoreQueryScopes<Keys>;
-    belongsTo<Columns extends ColumnsShapeBase, Related extends TableClass, Options extends BelongsToOptions<Columns, Related>>(this: {
+    }, scopes: DbTableOptionScopes<Table, Shape, Keys>): QueryScopes<Keys>;
+    belongsTo<Columns extends Column.Shape.QueryInit, Related extends TableClass, Options extends BelongsToOptions<Columns, Related>>(this: {
         columns: {
             shape: Columns;
         };
@@ -626,7 +626,7 @@ interface BaseTableInstance<ColumnTypes> {
         fn: () => Related;
         options: Options;
     };
-    hasOne<Columns extends ColumnsShapeBase, Related extends TableClass, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
+    hasOne<Columns extends Column.Shape.QueryInit, Related extends TableClass, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
         columns: {
             shape: Columns;
         };
@@ -635,7 +635,7 @@ interface BaseTableInstance<ColumnTypes> {
         fn: () => Related;
         options: Options;
     };
-    hasMany<Columns extends ColumnsShapeBase, Related extends TableClass, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
+    hasMany<Columns extends Column.Shape.QueryInit, Related extends TableClass, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
         columns: {
             shape: Columns;
         };
@@ -644,7 +644,7 @@ interface BaseTableInstance<ColumnTypes> {
         fn: () => Related;
         options: Options;
     };
-    hasAndBelongsToMany<Columns extends ColumnsShapeBase, Related extends TableClass, Options extends HasAndBelongsToManyOptions<Columns, Related>>(this: {
+    hasAndBelongsToMany<Columns extends Column.Shape.QueryInit, Related extends TableClass, Options extends HasAndBelongsToManyOptions<Columns, Related>>(this: {
         columns: {
             shape: Columns;
         };
@@ -673,8 +673,8 @@ interface BaseTableClass<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> {
     exportAs: string;
     columnTypes: ColumnTypes;
     getFilePath(): string;
-    sql<T>(...args: StaticSQLArgs): RawSQL<QueryColumn<T>, ColumnTypes>;
-    sql<T>(...args: [DynamicSQLArg<QueryColumn<T>>]): DynamicRawSQL<QueryColumn<T>, ColumnTypes>;
+    sql<T>(...args: StaticSQLArgs): RawSQL<Column.Pick.QueryColumnOfType<T>, ColumnTypes>;
+    sql<T>(...args: [DynamicSQLArg<Column.Pick.QueryColumnOfType<T>>]): DynamicRawSQL<Column.Pick.QueryColumnOfType<T>, ColumnTypes>;
     new (): BaseTableInstance<ColumnTypes>;
     instance(): BaseTableInstance<ColumnTypes>;
     /**

package/dist/index.js

@@ -402,45 +402,48 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
     super(schema);
     this.key = key;
     this.state = state;
-    this.nestedInsert = nestedInsert$3(this.state);
     this.nestedUpdate = nestedUpdate$3(this.state);
   }
-  create(q, ctx, item, rowIndex) {
+  create(q, ctx, item) {
     const {
       key,
-      state: { primaryKeys, foreignKeys }
+      state: { query, primaryKeys, foreignKeys }
     } = this;
-    const columnIndexes = foreignKeys.map((key2) => {
-      let index = ctx.columns.get(key2);
-      if (index === void 0) {
-        ctx.columns.set(key2, index = ctx.columns.size);
+    for (const key2 of foreignKeys) {
+      if (!ctx.columns.has(key2)) {
+        ctx.columns.set(key2, ctx.columns.size);
       }
-      return index;
-    });
-    const store = ctx;
-    if (!store.belongsTo) store.belongsTo = {};
-    const values = [rowIndex, columnIndexes, item[key]];
-    if (store.belongsTo[key]) {
-      store.belongsTo[key].push(values);
-      return;
     }
-    const relationData = [values];
-    store.belongsTo[key] = relationData;
-    q.q.wrapInTransaction = true;
-    pqb.pushQueryValueImmutable(q, "beforeCreate", async (q2) => {
-      const inserted = await this.nestedInsert(
-        q2,
-        relationData.map(([, , data]) => data)
+    const value = item[key];
+    if ("create" in value || "connectOrCreate" in value) {
+      foreignKeys.forEach((foreignKey) => item[foreignKey] = new pqb.RawSQL(""));
+      const selectPKeys = query.select(...primaryKeys);
+      pqb._with(
+        q,
+        (as) => {
+          foreignKeys.forEach((foreignKey, i) => {
+            item[foreignKey]._sql = `(SELECT "${as}"."${primaryKeys[i]}" FROM "${as}")`;
+          });
+        },
+        "create" in value ? pqb._queryCreate(selectPKeys, value.create) : pqb._orCreate(
+          pqb._queryWhere(selectPKeys, [
+            value.connectOrCreate.where
+          ]),
+          value.connectOrCreate.create
+        )
       );
-      const { values: values2 } = q2.q;
-      for (let i = 0, len = relationData.length; i < len; i++) {
-        const [rowIndex2, columnIndexes2] = relationData[i];
-        const row = values2[rowIndex2];
-        for (let c = 0, len2 = columnIndexes2.length; c < len2; c++) {
-          row[columnIndexes2[c]] = inserted[i][primaryKeys[c]];
-        }
-      }
-    });
+      return;
+    } else if ("connect" in value) {
+      const as = pqb.getFreeAlias(q.q.withShapes, "q");
+      pqb._with(q, as, query.select(...primaryKeys).findBy(value.connect));
+      foreignKeys.map((foreignKey, i) => {
+        const selectColumn = `(SELECT "${as}"."${primaryKeys[i]}" FROM "${as}")`;
+        item[foreignKey] = new pqb.RawSQL(
+          i === 0 ? `CASE WHEN (SELECT count(*) FROM "${as}") = 0 AND (SELECT 'not-found')::int = 0 THEN NULL ELSE ${selectColumn} END` : selectColumn
+        );
+      });
+      return;
+    }
   }
   update(q, ctx, set) {
     q.q.wrapInTransaction = true;
@@ -516,80 +519,6 @@ const makeBelongsToMethod = (tableConfig, table, relation, relationName, query)
     reverseJoin
   };
 };
-const nestedInsert$3 = ({ query, primaryKeys, on }) => {
-  return async (_, data) => {
-    const t = query.clone();
-    const items = [];
-    for (const item of data) {
-      if (item.connectOrCreate) {
-        items.push(
-          on ? {
-            ...item,
-            connectOrCreate: {
-              ...item.connectOrCreate,
-              where: { ...item.connectOrCreate.where, ...on }
-            }
-          } : item
-        );
-      }
-    }
-    let connectOrCreated;
-    if (items.length) {
-      for (let i = 0, len = items.length; i < len; i++) {
-        items[i] = t.findByOptional(
-          items[i].connectOrCreate.where
-        );
-      }
-      connectOrCreated = await Promise.all(items);
-    } else {
-      connectOrCreated = pqb.emptyArray;
-    }
-    let connectOrCreatedI = 0;
-    items.length = 0;
-    for (const item of data) {
-      if (item.connectOrCreate) {
-        if (!connectOrCreated[connectOrCreatedI++]) items.push(item);
-      } else if (item.create) {
-        items.push(item);
-      }
-    }
-    let created;
-    if (items.length) {
-      for (let i = 0, len = items.length; i < len; i++) {
-        items[i] = "create" in items[i] ? items[i].create : items[i].connectOrCreate.create;
-      }
-      created = await pqb._queryCreateMany(
-        t.select(...primaryKeys),
-        items
-      );
-    } else {
-      created = pqb.emptyArray;
-    }
-    items.length = 0;
-    for (const item of data) {
-      if (item.connect) {
-        items.push(
-          on ? { ...item, connect: { ...item.connect, ...on } } : item
-        );
-      }
-    }
-    let connected;
-    if (items.length) {
-      for (let i = 0, len = items.length; i < len; i++) {
-        items[i] = t.findBy(items[i].connect);
-      }
-      connected = await Promise.all(items);
-    } else {
-      connected = pqb.emptyArray;
-    }
-    let createdI = 0;
-    let connectedI = 0;
-    connectOrCreatedI = 0;
-    return data.map((item) => {
-      return item.connectOrCreate ? connectOrCreated[connectOrCreatedI++] || created[createdI++] : item.connect ? connected[connectedI++] : created[createdI++];
-    });
-  };
-};
 const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
   return (q, update, params, state) => {
     if (params.upsert && pqb.isQueryReturnsAll(q)) {
@@ -857,7 +786,7 @@ const makeHasOneMethod = (tableConfig, table, relation, relationName, query) =>
         const baseQuery = query2.clone();
         baseQuery.q.select = fromQuerySelect;
         const q = relationQuery.q;
-        q.insertFrom = baseQuery;
+        q.insertFrom = pqb.prepareSubQueryForSql(q, baseQuery);
         q.values = [];
       };
     }
@@ -1135,7 +1064,7 @@ const makeHasManyMethod = (tableConfig, table, relation, relationName, query) =>
         const baseQuery = query2.clone();
         baseQuery.q.select = fromQuerySelect;
         const q = relationQuery.q;
-        q.insertFrom = baseQuery;
+        q.insertFrom = pqb.prepareSubQueryForSql(q, baseQuery);
         q.values = [];
       };
     }
@@ -1407,7 +1336,9 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
   const primaryKeysShape = {};
   for (let i = 0; i < len; i++) {
     const pk = primaryKeys[i];
-    shape[foreignKeys[i]] = removeColumnName(table.shape[pk]);
+    shape[foreignKeys[i]] = removeColumnName(
+      table.shape[pk]
+    );
     primaryKeysShape[pk] = table.shape[pk];
   }
   for (let i = 0; i < throughLen; i++) {