orchid-orm 1.3.15 → 1.4.16

package/src/relations/hasAndBelongsToMany.ts

@@ -1,19 +1,22 @@
 import { RelationData, RelationThunkBase } from './relations';
-import { Model } from '../model';
+import { Table } from '../table';
 import {
+  CreateCtx,
   getQueryAs,
   HasAndBelongsToManyRelation,
-  HasManyNestedInsert,
-  HasManyNestedUpdate,
   MaybeArray,
   NotFoundError,
   pushQueryValue,
   Query,
   QueryBase,
   toSqlCacheKey,
+  UpdateCtx,
+  VirtualColumn,
   WhereArg,
   WhereResult,
 } from 'pqb';
+import { hasRelationHandleCreate, hasRelationHandleUpdate } from './utils';
+import { HasManyNestedInsert, HasManyNestedUpdate } from './hasMany';
 
 export interface HasAndBelongsToMany extends RelationThunkBase {
   type: 'hasAndBelongsToMany';
@@ -22,7 +25,7 @@ export interface HasAndBelongsToMany extends RelationThunkBase {
 }
 
 export type HasAndBelongsToManyInfo<
-  T extends Model,
+  T extends Table,
   Relation extends HasAndBelongsToMany,
 > = {
   params: Record<
@@ -41,12 +44,55 @@ type State = {
   foreignKey: string;
   associationPrimaryKey: string;
   associationForeignKey: string;
+  foreignKeyFull: string;
+  associationPrimaryKeyFull: string;
+  associationForeignKeyFull: string;
 };
 
+class HasAndBelongsToManyVirtualColumn extends VirtualColumn {
+  private readonly nestedInsert: HasManyNestedInsert;
+  private readonly nestedUpdate: HasManyNestedUpdate;
+
+  constructor(private key: string, private state: State) {
+    super();
+    this.nestedInsert = nestedInsert(state);
+    this.nestedUpdate = nestedUpdate(state);
+  }
+
+  create(
+    q: Query,
+    ctx: CreateCtx,
+    item: Record<string, unknown>,
+    rowIndex: number,
+  ) {
+    hasRelationHandleCreate(
+      q,
+      ctx,
+      item,
+      rowIndex,
+      this.key,
+      this.state.primaryKey,
+      this.nestedInsert,
+    );
+  }
+
+  update(q: Query, ctx: UpdateCtx, set: Record<string, unknown>) {
+    hasRelationHandleUpdate(
+      q,
+      ctx,
+      set,
+      this.key,
+      this.state.primaryKey,
+      this.nestedUpdate,
+    );
+  }
+}
+
 export const makeHasAndBelongsToManyMethod = (
-  model: Query,
+  table: Query,
   qb: Query,
   relation: HasAndBelongsToMany,
+  relationName: string,
   query: Query,
 ): RelationData => {
   const {
@@ -61,14 +107,14 @@ export const makeHasAndBelongsToManyMethod = (
   const associationForeignKeyFull = `${joinTable}.${afk}`;
   const associationPrimaryKeyFull = `${getQueryAs(query)}.${apk}`;
 
-  const __model = Object.create(qb.__model);
-  __model.__model = __model;
-  __model.table = joinTable;
-  __model.shape = {
-    [fk]: model.shape[pk],
+  const __table = Object.create(qb.__table);
+  __table.__table = __table;
+  __table.table = joinTable;
+  __table.shape = {
+    [fk]: table.shape[pk],
     [afk]: query.shape[apk],
   };
-  const subQuery = Object.create(__model);
+  const subQuery = Object.create(__table);
   subQuery.query = { ...subQuery.query };
 
   const state: State = {
@@ -78,6 +124,9 @@ export const makeHasAndBelongsToManyMethod = (
     foreignKey: fk,
     associationPrimaryKey: apk,
     associationForeignKey: afk,
+    foreignKeyFull,
+    associationForeignKeyFull,
+    associationPrimaryKeyFull,
   };
 
   return {
@@ -89,213 +138,7 @@ export const makeHasAndBelongsToManyMethod = (
         }),
       );
     },
-    nestedInsert: (async (q, data) => {
-      const connect = data.filter(
-        (
-          item,
-        ): item is [
-          selfData: Record<string, unknown>,
-          relationData: {
-            connect: WhereArg<QueryBase>[];
-          },
-        ] => Boolean(item[1].connect),
-      );
-
-      const t = query.transacting(q);
-
-      let connected: Record<string, unknown>[];
-      if (connect.length) {
-        connected = (await Promise.all(
-          connect.flatMap(([, { connect }]) =>
-            connect.map((item) => t.select(apk)._findBy(item)._take()),
-          ),
-        )) as Record<string, unknown[]>[];
-      } else {
-        connected = [];
-      }
-
-      const connectOrCreate = data.filter(
-        (
-          item,
-        ): item is [
-          Record<string, unknown>,
-          {
-            connectOrCreate: {
-              where: WhereArg<QueryBase>;
-              create: Record<string, unknown>;
-            }[];
-          },
-        ] => Boolean(item[1].connectOrCreate),
-      );
-
-      let connectOrCreated: (Record<string, unknown> | undefined)[];
-      if (connectOrCreate.length) {
-        connectOrCreated = await Promise.all(
-          connectOrCreate.flatMap(([, { connectOrCreate }]) =>
-            connectOrCreate.map((item) =>
-              t.select(apk)._findBy(item.where)._takeOptional(),
-            ),
-          ),
-        );
-      } else {
-        connectOrCreated = [];
-      }
-
-      let connectOrCreateI = 0;
-      const create = data.filter(
-        (
-          item,
-        ): item is [
-          Record<string, unknown>,
-          {
-            create?: Record<string, unknown>[];
-            connectOrCreate?: {
-              where: WhereArg<QueryBase>;
-              create: Record<string, unknown>;
-            }[];
-          },
-        ] => {
-          if (item[1].connectOrCreate) {
-            const length = item[1].connectOrCreate.length;
-            connectOrCreateI += length;
-            for (let i = length; i > 0; i--) {
-              if (!connectOrCreated[connectOrCreateI - i]) return true;
-            }
-          }
-          return Boolean(item[1].create);
-        },
-      );
-
-      connectOrCreateI = 0;
-      let created: Record<string, unknown>[];
-      if (create.length) {
-        created = (await t
-          .select(apk)
-          ._createMany(
-            create.flatMap(([, { create = [], connectOrCreate = [] }]) => [
-              ...create,
-              ...connectOrCreate
-                .filter(() => !connectOrCreated[connectOrCreateI++])
-                .map((item) => item.create),
-            ]),
-          )) as Record<string, unknown>[];
-      } else {
-        created = [];
-      }
-
-      const allKeys = data as unknown as [
-        selfData: Record<string, unknown>,
-        relationKeys: Record<string, unknown>[],
-      ][];
-
-      let createI = 0;
-      let connectI = 0;
-      connectOrCreateI = 0;
-      data.forEach(([, data], index) => {
-        if (data.create || data.connectOrCreate) {
-          if (data.create) {
-            const len = data.create.length;
-            allKeys[index][1] = created.slice(createI, createI + len);
-            createI += len;
-          }
-          if (data.connectOrCreate) {
-            const arr: Record<string, unknown>[] = [];
-            allKeys[index][1] = arr;
-
-            const len = data.connectOrCreate.length;
-            for (let i = 0; i < len; i++) {
-              const item = connectOrCreated[connectOrCreateI++];
-              if (item) {
-                arr.push(item);
-              } else {
-                arr.push(created[createI++]);
-              }
-            }
-          }
-        }
-
-        if (data.connect) {
-          const len = data.connect.length;
-          allKeys[index][1] = connected.slice(connectI, connectI + len);
-          connectI += len;
-        }
-      });
-
-      await subQuery
-        .transacting(q)
-        ._count()
-        ._createMany(
-          allKeys.flatMap(([selfData, relationKeys]) => {
-            const selfKey = selfData[pk];
-            return relationKeys.map((relationData) => ({
-              [fk]: selfKey,
-              [afk]: relationData[apk],
-            }));
-          }),
-        );
-    }) as HasManyNestedInsert,
-    nestedUpdate: (async (q, data, params) => {
-      if (params.create) {
-        const ids = await query
-          .transacting(q)
-          ._pluck(apk)
-          ._createMany(params.create);
-
-        await subQuery.transacting(q)._createMany(
-          data.flatMap((item) =>
-            ids.map((id) => ({
-              [fk]: item[pk],
-              [afk]: id,
-            })),
-          ),
-        );
-      }
-
-      if (params.update) {
-        await (
-          query
-            .transacting(q)
-            ._whereExists(subQuery, (q) =>
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              (q as any)
-                ._on(associationForeignKeyFull, associationPrimaryKeyFull)
-                ._where({
-                  IN: {
-                    columns: [foreignKeyFull],
-                    values: [data.map((item) => item[pk])],
-                  },
-                }),
-            )
-            ._where(
-              Array.isArray(params.update.where)
-                ? { OR: params.update.where }
-                : params.update.where,
-            ) as WhereResult<Query>
-        )._update<WhereResult<Query>>(params.update.data);
-      }
-
-      if (params.disconnect) {
-        await queryJoinTable(state, q, data, params.disconnect)._delete();
-      }
-
-      if (params.delete) {
-        const j = queryJoinTable(state, q, data, params.delete);
-
-        const ids = await j._pluck(afk)._delete();
-
-        await queryRelatedTable(query, q, { [apk]: { in: ids } })._delete();
-      }
-
-      if (params.set) {
-        const j = queryJoinTable(state, q, data);
-        await j._delete();
-        delete j.query[toSqlCacheKey];
-
-        const ids = await queryRelatedTable(query, q, params.set)._pluck(apk);
-
-        await insertToJoinTable(state, j, data, ids);
-      }
-    }) as HasManyNestedUpdate,
+    virtualColumn: new HasAndBelongsToManyVirtualColumn(relationName, state),
     // joinQuery can be a property of RelationQuery and be used by whereExists and other stuff which needs it
     // and the chained query itself may be a query around this joinQuery
     joinQuery(fromQuery, toQuery) {
@@ -396,3 +239,234 @@ const insertToJoinTable = (
     ),
   );
 };
+
+const nestedInsert = ({
+  relatedTableQuery,
+  joinTableQuery,
+  primaryKey,
+  foreignKey,
+  associationPrimaryKey,
+  associationForeignKey,
+}: State) => {
+  return (async (q, data) => {
+    const connect = data.filter(
+      (
+        item,
+      ): item is [
+        selfData: Record<string, unknown>,
+        relationData: {
+          connect: WhereArg<QueryBase>[];
+        },
+      ] => Boolean(item[1].connect),
+    );
+
+    const t = relatedTableQuery.transacting(q);
+
+    let connected: Record<string, unknown>[];
+    if (connect.length) {
+      connected = (await Promise.all(
+        connect.flatMap(([, { connect }]) =>
+          connect.map((item) =>
+            t.select(associationPrimaryKey)._findBy(item)._take(),
+          ),
+        ),
+      )) as Record<string, unknown[]>[];
+    } else {
+      connected = [];
+    }
+
+    const connectOrCreate = data.filter(
+      (
+        item,
+      ): item is [
+        Record<string, unknown>,
+        {
+          connectOrCreate: {
+            where: WhereArg<QueryBase>;
+            create: Record<string, unknown>;
+          }[];
+        },
+      ] => Boolean(item[1].connectOrCreate),
+    );
+
+    let connectOrCreated: (Record<string, unknown> | undefined)[];
+    if (connectOrCreate.length) {
+      connectOrCreated = await Promise.all(
+        connectOrCreate.flatMap(([, { connectOrCreate }]) =>
+          connectOrCreate.map((item) =>
+            t.select(associationPrimaryKey)._findBy(item.where)._takeOptional(),
+          ),
+        ),
+      );
+    } else {
+      connectOrCreated = [];
+    }
+
+    let connectOrCreateI = 0;
+    const create = data.filter(
+      (
+        item,
+      ): item is [
+        Record<string, unknown>,
+        {
+          create?: Record<string, unknown>[];
+          connectOrCreate?: {
+            where: WhereArg<QueryBase>;
+            create: Record<string, unknown>;
+          }[];
+        },
+      ] => {
+        if (item[1].connectOrCreate) {
+          const length = item[1].connectOrCreate.length;
+          connectOrCreateI += length;
+          for (let i = length; i > 0; i--) {
+            if (!connectOrCreated[connectOrCreateI - i]) return true;
+          }
+        }
+        return Boolean(item[1].create);
+      },
+    );
+
+    connectOrCreateI = 0;
+    let created: Record<string, unknown>[];
+    if (create.length) {
+      created = (await t
+        .select(associationPrimaryKey)
+        ._createMany(
+          create.flatMap(([, { create = [], connectOrCreate = [] }]) => [
+            ...create,
+            ...connectOrCreate
+              .filter(() => !connectOrCreated[connectOrCreateI++])
+              .map((item) => item.create),
+          ]),
+        )) as Record<string, unknown>[];
+    } else {
+      created = [];
+    }
+
+    const allKeys = data as unknown as [
+      selfData: Record<string, unknown>,
+      relationKeys: Record<string, unknown>[],
+    ][];
+
+    let createI = 0;
+    let connectI = 0;
+    connectOrCreateI = 0;
+    data.forEach(([, data], index) => {
+      if (data.create || data.connectOrCreate) {
+        if (data.create) {
+          const len = data.create.length;
+          allKeys[index][1] = created.slice(createI, createI + len);
+          createI += len;
+        }
+        if (data.connectOrCreate) {
+          const arr: Record<string, unknown>[] = [];
+          allKeys[index][1] = arr;
+
+          const len = data.connectOrCreate.length;
+          for (let i = 0; i < len; i++) {
+            const item = connectOrCreated[connectOrCreateI++];
+            if (item) {
+              arr.push(item);
+            } else {
+              arr.push(created[createI++]);
+            }
+          }
+        }
+      }
+
+      if (data.connect) {
+        const len = data.connect.length;
+        allKeys[index][1] = connected.slice(connectI, connectI + len);
+        connectI += len;
+      }
+    });
+
+    await joinTableQuery
+      .transacting(q)
+      ._count()
+      ._createMany(
+        allKeys.flatMap(([selfData, relationKeys]) => {
+          const selfKey = selfData[primaryKey];
+          return relationKeys.map((relationData) => ({
+            [foreignKey]: selfKey,
+            [associationForeignKey]: relationData[associationPrimaryKey],
+          }));
+        }),
+      );
+  }) as HasManyNestedInsert;
+};
+
+const nestedUpdate = (state: State) => {
+  return (async (q, data, params) => {
+    if (params.create) {
+      const ids = await state.relatedTableQuery
+        .transacting(q)
+        ._pluck(state.associationPrimaryKey)
+        ._createMany(params.create);
+
+      await state.joinTableQuery.transacting(q)._createMany(
+        data.flatMap((item) =>
+          ids.map((id) => ({
+            [state.foreignKey]: item[state.primaryKey],
+            [state.associationForeignKey]: id,
+          })),
+        ),
+      );
+    }
+
+    if (params.update) {
+      await (
+        state.relatedTableQuery
+          .transacting(q)
+          ._whereExists(state.joinTableQuery, (q) =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (q as any)
+              ._on(
+                state.associationForeignKeyFull,
+                state.associationPrimaryKeyFull,
+              )
+              ._where({
+                IN: {
+                  columns: [state.foreignKeyFull],
+                  values: [data.map((item) => item[state.primaryKey])],
+                },
+              }),
+          )
+          ._where(
+            Array.isArray(params.update.where)
+              ? { OR: params.update.where }
+              : params.update.where,
+          ) as WhereResult<Query>
+      )._update<WhereResult<Query>>(params.update.data);
+    }
+
+    if (params.disconnect) {
+      await queryJoinTable(state, q, data, params.disconnect)._delete();
+    }
+
+    if (params.delete) {
+      const j = queryJoinTable(state, q, data, params.delete);
+
+      const ids = await j._pluck(state.associationForeignKey)._delete();
+
+      await queryRelatedTable(state.relatedTableQuery, q, {
+        [state.associationPrimaryKey]: { in: ids },
+      })._delete();
+    }
+
+    if (params.set) {
+      const j = queryJoinTable(state, q, data);
+      await j._delete();
+      delete j.query[toSqlCacheKey];
+
+      const ids = await queryRelatedTable(
+        state.relatedTableQuery,
+        q,
+        params.set,
+      )._pluck(state.associationPrimaryKey);
+
+      await insertToJoinTable(state, j, data, ids);
+    }
+  }) as HasManyNestedUpdate;
+};

package/src/relations/hasMany.test.ts

@@ -9,7 +9,13 @@ import {
   useTestDatabase,
 } from '../test-utils/test-utils';
 import { RelationQuery } from 'pqb';
-import { Chat, Message, Model, Profile, User } from '../test-utils/test-models';
+import {
+  Chat,
+  Message,
+  BaseTable,
+  Profile,
+  User,
+} from '../test-utils/test-tables';
 import { orchidORM } from '../orm';
 
 describe('hasMany', () => {
@@ -1653,8 +1659,8 @@ describe('hasMany', () => {
 });
 
 describe('hasMany through', () => {
-  it('should resolve recursive situation when both models depends on each other', () => {
-    class Post extends Model {
+  it('should resolve recursive situation when both tables depends on each other', () => {
+    class Post extends BaseTable {
       table = 'post';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1673,7 +1679,7 @@ describe('hasMany through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1692,7 +1698,7 @@ describe('hasMany through', () => {
       };
     }
 
-    class PostTag extends Model {
+    class PostTag extends BaseTable {
       table = 'postTag';
       columns = this.setColumns((t) => ({
         postId: t.integer().foreignKey(() => Post, 'id'),
@@ -1730,7 +1736,7 @@ describe('hasMany through', () => {
   });
 
   it('should throw if through relation is not defined', () => {
-    class Post extends Model {
+    class Post extends BaseTable {
       table = 'post';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1744,7 +1750,7 @@ describe('hasMany through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1768,7 +1774,7 @@ describe('hasMany through', () => {
   });
 
   it('should throw if source relation is not defined', () => {
-    class Post extends Model {
+    class Post extends BaseTable {
       table = 'post';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1787,14 +1793,14 @@ describe('hasMany through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
       }));
     }
 
-    class PostTag extends Model {
+    class PostTag extends BaseTable {
       table = 'postTag';
       columns = this.setColumns((t) => ({
         postId: t.integer().foreignKey(() => Post, 'id'),