orchid-orm 1.3.15 → 1.4.16

package/src/relations/hasMany.ts

@@ -4,12 +4,10 @@ import {
   RelationThunkBase,
   RelationThunks,
 } from './relations';
-import { Model } from '../model';
+import { Table } from '../table';
 import {
   addQueryOn,
   getQueryAs,
-  HasManyNestedInsert,
-  HasManyNestedUpdate,
   HasManyRelation,
   CreateData,
   JoinCallback,
@@ -21,8 +19,18 @@ import {
   WhereResult,
   InsertQueryData,
   isQueryReturnsAll,
+  VirtualColumn,
+  CreateCtx,
+  UpdateCtx,
 } from 'pqb';
-import { getSourceRelation, getThroughRelation } from './utils';
+import {
+  getSourceRelation,
+  getThroughRelation,
+  hasRelationHandleCreate,
+  hasRelationHandleUpdate,
+  NestedInsertManyItems,
+  NestedUpdateManyItems,
+} from './utils';
 
 export interface HasMany extends RelationThunkBase {
   type: 'hasMany';
@@ -31,7 +39,7 @@ export interface HasMany extends RelationThunkBase {
 }
 
 export type HasManyInfo<
-  T extends Model,
+  T extends Table,
   Relations extends RelationThunks,
   Relation extends HasMany,
 > = {
@@ -56,8 +64,67 @@ export type HasManyInfo<
   chainedDelete: true;
 };
 
+type State = {
+  query: Query;
+  primaryKey: string;
+  foreignKey: string;
+};
+
+export type HasManyNestedUpdate = (
+  query: Query,
+  data: Record<string, unknown>[],
+  relationData: NestedUpdateManyItems,
+) => Promise<void>;
+
+export type HasManyNestedInsert = (
+  query: Query,
+  data: [
+    selfData: Record<string, unknown>,
+    relationData: NestedInsertManyItems,
+  ][],
+) => Promise<void>;
+
+class HasManyVirtualColumn 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 makeHasManyMethod = (
-  model: Query,
+  table: Query,
   relation: HasMany,
   relationName: string,
   query: Query,
@@ -65,12 +132,12 @@ export const makeHasManyMethod = (
   if ('through' in relation.options) {
     const { through, source } = relation.options;
 
-    type ModelWithQueryMethod = Record<
+    type TableWithQueryMethod = Record<
       string,
       (params: Record<string, unknown>) => Query
     >;
 
-    const throughRelation = getThroughRelation(model, through);
+    const throughRelation = getThroughRelation(table, through);
     const sourceRelation = getSourceRelation(throughRelation, source);
     const sourceRelationQuery = sourceRelation.query.as(relationName);
     const sourceQuery = sourceRelation.joinQuery(
@@ -83,7 +150,7 @@ export const makeHasManyMethod = (
     return {
       returns: 'many',
       method: (params: Record<string, unknown>) => {
-        const throughQuery = (model as unknown as ModelWithQueryMethod)[
+        const throughQuery = (table as unknown as TableWithQueryMethod)[
           through
         ](params);
 
@@ -92,8 +159,6 @@ export const makeHasManyMethod = (
           whereExistsCallback as unknown as JoinCallback<Query, Query>,
         );
       },
-      nestedInsert: undefined,
-      nestedUpdate: undefined,
       joinQuery(fromQuery, toQuery) {
         return toQuery.whereExists<Query, Query>(
           throughRelation.joinQuery(fromQuery, throughRelation.query),
@@ -123,6 +188,7 @@ export const makeHasManyMethod = (
   }
 
   const { primaryKey, foreignKey } = relation.options;
+  const state: State = { query, primaryKey, foreignKey };
 
   const fromQuerySelect = [{ selectAs: { [foreignKey]: primaryKey } }];
 
@@ -132,167 +198,7 @@ export const makeHasManyMethod = (
       const values = { [foreignKey]: params[primaryKey] };
       return query.where(values)._defaults(values);
     },
-    nestedInsert: (async (q, data) => {
-      const connect = data.filter(
-        (
-          item,
-        ): item is [
-          Record<string, unknown>,
-          { connect: WhereArg<QueryBase>[] },
-        ] => Boolean(item[1].connect),
-      );
-
-      const t = query.transacting(q);
-
-      if (connect.length) {
-        await Promise.all(
-          connect.flatMap(([selfData, { connect }]) =>
-            t
-              .or<Query>(...connect)
-              ._updateOrThrow({ [foreignKey]: selfData[primaryKey] }),
-          ),
-        );
-      }
-
-      const connectOrCreate = data.filter(
-        (
-          item,
-        ): item is [
-          Record<string, unknown>,
-          {
-            connectOrCreate: {
-              where: WhereArg<QueryBase>;
-              create: Record<string, unknown>;
-            }[];
-          },
-        ] => Boolean(item[1].connectOrCreate),
-      );
-
-      let connected: number[];
-      if (connectOrCreate.length) {
-        connected = await Promise.all(
-          connectOrCreate.flatMap(([selfData, { connectOrCreate }]) =>
-            connectOrCreate.map((item) =>
-              (
-                t.where(item.where) as WhereResult<Query & { hasSelect: false }>
-              )._update({
-                [foreignKey]: selfData[primaryKey],
-              }),
-            ),
-          ),
-        );
-      } else {
-        connected = [];
-      }
-
-      let connectedI = 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;
-            connectedI += length;
-            for (let i = length; i > 0; i--) {
-              if (connected[connectedI - i] === 0) return true;
-            }
-          }
-          return Boolean(item[1].create);
-        },
-      );
-
-      connectedI = 0;
-      if (create.length) {
-        await t._createMany(
-          create.flatMap(
-            ([selfData, { create = [], connectOrCreate = [] }]) => {
-              return [
-                ...create.map((item) => ({
-                  [foreignKey]: selfData[primaryKey],
-                  ...item,
-                })),
-                ...connectOrCreate
-                  .filter(() => connected[connectedI++] === 0)
-                  .map((item) => ({
-                    [foreignKey]: selfData[primaryKey],
-                    ...item.create,
-                  })),
-              ];
-            },
-          ) as CreateData<Query>[],
-        );
-      }
-    }) as HasManyNestedInsert,
-    nestedUpdate: (async (q, data, params) => {
-      if ((params.set || params.create) && isQueryReturnsAll(q)) {
-        const key = params.set ? 'set' : 'create';
-        throw new Error(`\`${key}\` option is not allowed in a batch update`);
-      }
-
-      const t = query.transacting(q);
-      if (params.create) {
-        await t._count()._createMany(
-          params.create.map((create) => ({
-            ...create,
-            [foreignKey]: data[0][primaryKey],
-          })),
-        );
-        delete t.query[toSqlCacheKey];
-      }
-
-      if (params.disconnect || params.set) {
-        await t
-          .where<Query>(
-            getWhereForNestedUpdate(
-              data,
-              params.disconnect,
-              primaryKey,
-              foreignKey,
-            ),
-          )
-          ._update({ [foreignKey]: null });
-
-        if (params.set) {
-          delete t.query[toSqlCacheKey];
-          await t
-            .where<Query>(
-              Array.isArray(params.set)
-                ? {
-                    OR: params.set,
-                  }
-                : params.set,
-            )
-            ._update({ [foreignKey]: data[0][primaryKey] });
-        }
-      }
-
-      if (params.delete || params.update) {
-        delete t.query[toSqlCacheKey];
-        const q = t._where(
-          getWhereForNestedUpdate(
-            data,
-            params.delete || params.update?.where,
-            primaryKey,
-            foreignKey,
-          ),
-        );
-
-        if (params.delete) {
-          await q._delete();
-        } else if (params.update) {
-          await q._update<WhereResult<Query>>(params.update.data);
-        }
-      }
-    }) as HasManyNestedUpdate,
+    virtualColumn: new HasManyVirtualColumn(relationName, state),
     joinQuery(fromQuery, toQuery) {
       return addQueryOn(toQuery, fromQuery, toQuery, foreignKey, primaryKey);
     },
@@ -328,3 +234,168 @@ const getWhereForNestedUpdate = (
   }
   return where;
 };
+
+const nestedInsert = ({ query, primaryKey, foreignKey }: State) => {
+  return (async (q, data) => {
+    const connect = data.filter(
+      (
+        item,
+      ): item is [
+        Record<string, unknown>,
+        { connect: WhereArg<QueryBase>[] },
+      ] => Boolean(item[1].connect),
+    );
+
+    const t = query.transacting(q);
+
+    if (connect.length) {
+      await Promise.all(
+        connect.flatMap(([selfData, { connect }]) =>
+          t
+            .or<Query>(...connect)
+            ._updateOrThrow({ [foreignKey]: selfData[primaryKey] }),
+        ),
+      );
+    }
+
+    const connectOrCreate = data.filter(
+      (
+        item,
+      ): item is [
+        Record<string, unknown>,
+        {
+          connectOrCreate: {
+            where: WhereArg<QueryBase>;
+            create: Record<string, unknown>;
+          }[];
+        },
+      ] => Boolean(item[1].connectOrCreate),
+    );
+
+    let connected: number[];
+    if (connectOrCreate.length) {
+      connected = await Promise.all(
+        connectOrCreate.flatMap(([selfData, { connectOrCreate }]) =>
+          connectOrCreate.map((item) =>
+            (
+              t.where(item.where) as WhereResult<Query & { hasSelect: false }>
+            )._update({
+              [foreignKey]: selfData[primaryKey],
+            }),
+          ),
+        ),
+      );
+    } else {
+      connected = [];
+    }
+
+    let connectedI = 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;
+          connectedI += length;
+          for (let i = length; i > 0; i--) {
+            if (connected[connectedI - i] === 0) return true;
+          }
+        }
+        return Boolean(item[1].create);
+      },
+    );
+
+    connectedI = 0;
+    if (create.length) {
+      await t._createMany(
+        create.flatMap(([selfData, { create = [], connectOrCreate = [] }]) => {
+          return [
+            ...create.map((item) => ({
+              [foreignKey]: selfData[primaryKey],
+              ...item,
+            })),
+            ...connectOrCreate
+              .filter(() => connected[connectedI++] === 0)
+              .map((item) => ({
+                [foreignKey]: selfData[primaryKey],
+                ...item.create,
+              })),
+          ];
+        }) as CreateData<Query>[],
+      );
+    }
+  }) as HasManyNestedInsert;
+};
+
+const nestedUpdate = ({ query, primaryKey, foreignKey }: State) => {
+  return (async (q, data, params) => {
+    if ((params.set || params.create) && isQueryReturnsAll(q)) {
+      const key = params.set ? 'set' : 'create';
+      throw new Error(`\`${key}\` option is not allowed in a batch update`);
+    }
+
+    const t = query.transacting(q);
+    if (params.create) {
+      await t._count()._createMany(
+        params.create.map((create) => ({
+          ...create,
+          [foreignKey]: data[0][primaryKey],
+        })),
+      );
+      delete t.query[toSqlCacheKey];
+    }
+
+    if (params.disconnect || params.set) {
+      await t
+        .where<Query>(
+          getWhereForNestedUpdate(
+            data,
+            params.disconnect,
+            primaryKey,
+            foreignKey,
+          ),
+        )
+        ._update({ [foreignKey]: null });
+
+      if (params.set) {
+        delete t.query[toSqlCacheKey];
+        await t
+          .where<Query>(
+            Array.isArray(params.set)
+              ? {
+                  OR: params.set,
+                }
+              : params.set,
+          )
+          ._update({ [foreignKey]: data[0][primaryKey] });
+      }
+    }
+
+    if (params.delete || params.update) {
+      delete t.query[toSqlCacheKey];
+      const q = t._where(
+        getWhereForNestedUpdate(
+          data,
+          params.delete || params.update?.where,
+          primaryKey,
+          foreignKey,
+        ),
+      );
+
+      if (params.delete) {
+        await q._delete();
+      } else if (params.update) {
+        await q._update<WhereResult<Query>>(params.update.data);
+      }
+    }
+  }) as HasManyNestedUpdate;
+};

package/src/relations/hasOne.test.ts

@@ -8,7 +8,7 @@ import {
   useRelationCallback,
   useTestDatabase,
 } from '../test-utils/test-utils';
-import { User, Profile, Model } from '../test-utils/test-models';
+import { User, Profile, BaseTable } from '../test-utils/test-tables';
 import { RelationQuery } from 'pqb';
 import { orchidORM } from '../orm';
 
@@ -1264,8 +1264,8 @@ describe('hasOne', () => {
 });
 
 describe('hasOne 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(),
@@ -1284,7 +1284,7 @@ describe('hasOne through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1303,7 +1303,7 @@ describe('hasOne through', () => {
       };
     }
 
-    class PostTag extends Model {
+    class PostTag extends BaseTable {
       table = 'postTag';
       columns = this.setColumns((t) => ({
         postId: t.integer().foreignKey(() => Post, 'id'),
@@ -1341,7 +1341,7 @@ describe('hasOne 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(),
@@ -1355,7 +1355,7 @@ describe('hasOne through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1379,7 +1379,7 @@ describe('hasOne 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(),
@@ -1398,14 +1398,14 @@ describe('hasOne 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'),