orchid-orm 1.3.14 → 1.3.16

package/src/relations/hasOne.ts

@@ -1,14 +1,15 @@
 import {
   addQueryOn,
+  CreateCtx,
   getQueryAs,
-  HasOneNestedInsert,
-  HasOneNestedUpdate,
   HasOneRelation,
   InsertQueryData,
   isQueryReturnsAll,
   JoinCallback,
   Query,
   QueryBase,
+  UpdateCtx,
+  VirtualColumn,
   WhereArg,
   WhereResult,
 } from 'pqb';
@@ -19,7 +20,14 @@ import {
   RelationThunkBase,
   RelationThunks,
 } from './relations';
-import { getSourceRelation, getThroughRelation } from './utils';
+import {
+  getSourceRelation,
+  getThroughRelation,
+  hasRelationHandleCreate,
+  hasRelationHandleUpdate,
+  NestedInsertOneItem,
+  NestedUpdateOneItem,
+} from './utils';
 
 export interface HasOne extends RelationThunkBase {
   type: 'hasOne';
@@ -53,6 +61,65 @@ export type HasOneInfo<
   chainedDelete: true;
 };
 
+type State = {
+  query: Query;
+  primaryKey: string;
+  foreignKey: string;
+};
+
+export type HasOneNestedInsert = (
+  query: Query,
+  data: [
+    selfData: Record<string, unknown>,
+    relationData: NestedInsertOneItem,
+  ][],
+) => Promise<void>;
+
+export type HasOneNestedUpdate = (
+  query: Query,
+  data: Record<string, unknown>[],
+  relationData: NestedUpdateOneItem,
+) => Promise<void>;
+
+class HasOneVirtualColumn extends VirtualColumn {
+  private readonly nestedInsert: HasOneNestedInsert;
+  private readonly nestedUpdate: HasOneNestedUpdate;
+
+  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 makeHasOneMethod = (
   model: Query,
   relation: HasOne,
@@ -93,8 +160,6 @@ export const makeHasOneMethod = (
           whereExistsCallback as unknown as JoinCallback<Query, Query>,
         );
       },
-      nestedInsert: undefined,
-      nestedUpdate: undefined,
       joinQuery(fromQuery, toQuery) {
         return toQuery.whereExists<Query, Query>(
           throughRelation.joinQuery(fromQuery, throughRelation.query),
@@ -124,6 +189,7 @@ export const makeHasOneMethod = (
   }
 
   const { primaryKey, foreignKey } = relation.options;
+  const state: State = { query, primaryKey, foreignKey };
 
   const fromQuerySelect = [{ selectAs: { [foreignKey]: primaryKey } }];
 
@@ -133,133 +199,7 @@ export const makeHasOneMethod = (
       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>;
-              }
-            | {
-                connectOrCreate: {
-                  where: WhereArg<QueryBase>;
-                  create: Record<string, unknown>;
-                };
-              }
-          ),
-        ] => Boolean(item[1].connect || item[1].connectOrCreate),
-      );
-
-      const t = query.transacting(q);
-
-      let connected: number[];
-      if (connect.length) {
-        connected = await Promise.all(
-          connect.map(([selfData, item]) => {
-            const data = { [foreignKey]: selfData[primaryKey] };
-            return 'connect' in item
-              ? (
-                  t.where(item.connect) as WhereResult<Query> & {
-                    hasSelect: false;
-                  }
-                )._updateOrThrow(data)
-              : (
-                  t.where(item.connectOrCreate.where) as WhereResult<Query> & {
-                    hasSelect: false;
-                  }
-                )._update(data);
-          }),
-        );
-      } 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) {
-            return !connected[connectedI++];
-          }
-          return Boolean(item[1].create);
-        },
-      );
-
-      if (create.length) {
-        await t._count()._createMany(
-          create.map(([selfData, item]) => ({
-            [foreignKey]: selfData[primaryKey],
-            ...('create' in item ? item.create : item.connectOrCreate.create),
-          })),
-        );
-      }
-    }) as HasOneNestedInsert,
-    nestedUpdate: (async (q, data, params) => {
-      if (
-        (params.set || params.create || params.upsert) &&
-        isQueryReturnsAll(q)
-      ) {
-        const key = params.set ? 'set' : params.create ? 'create' : 'upsert';
-        throw new Error(`\`${key}\` option is not allowed in a batch update`);
-      }
-
-      const t = query.transacting(q);
-      const ids = data.map((item) => item[primaryKey]);
-      const currentRelationsQuery = t.where({
-        [foreignKey]: { in: ids },
-      });
-
-      if (params.create || params.disconnect || params.set) {
-        await currentRelationsQuery._update({ [foreignKey]: null });
-
-        if (params.create) {
-          await t._count()._create({
-            ...params.create,
-            [foreignKey]: data[0][primaryKey],
-          });
-        }
-        if (params.set) {
-          await t
-            ._where<Query>(params.set)
-            ._update({ [foreignKey]: data[0][primaryKey] });
-        }
-      } else if (params.update) {
-        await currentRelationsQuery._update<WhereResult<Query>>(params.update);
-      } else if (params.delete) {
-        await currentRelationsQuery._delete();
-      } else if (params.upsert) {
-        const { update, create } = params.upsert;
-        const updatedIds: unknown[] = await currentRelationsQuery
-          ._pluck(foreignKey)
-          ._update<WhereResult<Query & { hasSelect: true }>>(update);
-
-        if (updatedIds.length < ids.length) {
-          await t.createMany(
-            ids
-              .filter((id) => !updatedIds.includes(id))
-              .map((id) => ({
-                ...create,
-                [foreignKey]: id,
-              })),
-          );
-        }
-      }
-    }) as HasOneNestedUpdate,
+    virtualColumn: new HasOneVirtualColumn(relationName, state),
     joinQuery(fromQuery, toQuery) {
       return addQueryOn(toQuery, fromQuery, toQuery, foreignKey, primaryKey);
     },
@@ -276,3 +216,136 @@ export const makeHasOneMethod = (
     },
   };
 };
+
+const nestedInsert = ({ query, primaryKey, foreignKey }: State) => {
+  return (async (q, data) => {
+    const connect = data.filter(
+      (
+        item,
+      ): item is [
+        Record<string, unknown>,
+        (
+          | {
+              connect: WhereArg<QueryBase>;
+            }
+          | {
+              connectOrCreate: {
+                where: WhereArg<QueryBase>;
+                create: Record<string, unknown>;
+              };
+            }
+        ),
+      ] => Boolean(item[1].connect || item[1].connectOrCreate),
+    );
+
+    const t = query.transacting(q);
+
+    let connected: number[];
+    if (connect.length) {
+      connected = await Promise.all(
+        connect.map(([selfData, item]) => {
+          const data = { [foreignKey]: selfData[primaryKey] };
+          return 'connect' in item
+            ? (
+                t.where(item.connect) as WhereResult<Query> & {
+                  hasSelect: false;
+                }
+              )._updateOrThrow(data)
+            : (
+                t.where(item.connectOrCreate.where) as WhereResult<Query> & {
+                  hasSelect: false;
+                }
+              )._update(data);
+        }),
+      );
+    } 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) {
+          return !connected[connectedI++];
+        }
+        return Boolean(item[1].create);
+      },
+    );
+
+    if (create.length) {
+      await t._count()._createMany(
+        create.map(([selfData, item]) => ({
+          [foreignKey]: selfData[primaryKey],
+          ...('create' in item ? item.create : item.connectOrCreate.create),
+        })),
+      );
+    }
+  }) as HasOneNestedInsert;
+};
+
+const nestedUpdate = ({ query, primaryKey, foreignKey }: State) => {
+  return (async (q, data, params) => {
+    if (
+      (params.set || params.create || params.upsert) &&
+      isQueryReturnsAll(q)
+    ) {
+      const key = params.set ? 'set' : params.create ? 'create' : 'upsert';
+      throw new Error(`\`${key}\` option is not allowed in a batch update`);
+    }
+
+    const t = query.transacting(q);
+    const ids = data.map((item) => item[primaryKey]);
+    const currentRelationsQuery = t.where({
+      [foreignKey]: { in: ids },
+    });
+
+    if (params.create || params.disconnect || params.set) {
+      await currentRelationsQuery._update({ [foreignKey]: null });
+
+      if (params.create) {
+        await t._count()._create({
+          ...params.create,
+          [foreignKey]: data[0][primaryKey],
+        });
+      }
+      if (params.set) {
+        await t
+          ._where<Query>(params.set)
+          ._update({ [foreignKey]: data[0][primaryKey] });
+      }
+    } else if (params.update) {
+      await currentRelationsQuery._update<WhereResult<Query>>(params.update);
+    } else if (params.delete) {
+      await currentRelationsQuery._delete();
+    } else if (params.upsert) {
+      const { update, create } = params.upsert;
+      const updatedIds: unknown[] = await currentRelationsQuery
+        ._pluck(foreignKey)
+        ._update<WhereResult<Query & { hasSelect: true }>>(update);
+
+      if (updatedIds.length < ids.length) {
+        await t.createMany(
+          ids
+            .filter((id) => !updatedIds.includes(id))
+            .map((id) => ({
+              ...create,
+              [foreignKey]: id,
+            })),
+        );
+      }
+    }
+  }) as HasOneNestedUpdate;
+};

package/src/relations/relations.ts

@@ -13,6 +13,7 @@ import {
   defaultsKey,
   relationQueryKey,
   EmptyObject,
+  VirtualColumn,
 } from 'pqb';
 import { HasMany, HasManyInfo, makeHasManyMethod } from './hasMany';
 import {
@@ -36,8 +37,7 @@ export type RelationThunks = Record<string, RelationThunk>;
 export type RelationData = {
   returns: 'one' | 'many';
   method(params: Record<string, unknown>): Query;
-  nestedInsert: BaseRelation['nestedInsert'];
-  nestedUpdate: BaseRelation['nestedUpdate'];
+  virtualColumn?: VirtualColumn;
   joinQuery(fromQuery: Query, toQuery: Query): Query;
   reverseJoin(fromQuery: Query, toQuery: Query): Query;
   primaryKey: string;
@@ -63,8 +63,6 @@ export type Relation<
     : M & {
         [defaultsKey]: Record<Info['populate'], true>;
       };
-  nestedInsert: BaseRelation['nestedInsert'];
-  nestedUpdate: BaseRelation['nestedUpdate'];
   primaryKey: string;
   options: Relations[K]['options'];
 };
@@ -280,13 +278,19 @@ const applyRelation = (
   const { type } = relation;
   let data;
   if (type === 'belongsTo') {
-    data = makeBelongsToMethod(relation, query);
+    data = makeBelongsToMethod(relation, relationName, query);
   } else if (type === 'hasOne') {
     data = makeHasOneMethod(dbModel, relation, relationName, query);
   } else if (type === 'hasMany') {
     data = makeHasManyMethod(dbModel, relation, relationName, query);
   } else if (type === 'hasAndBelongsToMany') {
-    data = makeHasAndBelongsToManyMethod(dbModel, qb, relation, query);
+    data = makeHasAndBelongsToManyMethod(
+      dbModel,
+      qb,
+      relation,
+      relationName,
+      query,
+    );
   } else {
     throw new Error(`Unknown relation type ${type}`);
   }
@@ -295,6 +299,10 @@ const applyRelation = (
     query._take();
   }
 
+  if (data.virtualColumn) {
+    dbModel.shape[relationName] = data.virtualColumn;
+  }
+
   makeRelationQuery(dbModel, definedAs, relationName, data);
 
   (dbModel.relations as Record<string, unknown>)[relationName] = {
@@ -302,8 +310,6 @@ const applyRelation = (
     key: relationName,
     model: otherDbModel,
     query,
-    nestedInsert: data.nestedInsert,
-    nestedUpdate: data.nestedUpdate,
     joinQuery: data.joinQuery,
     primaryKey: data.primaryKey,
     options: relation.options,

package/src/relations/utils.ts

@@ -1,4 +1,61 @@
-import { Query, Relation } from 'pqb';
+import {
+  CreateCtx,
+  MaybeArray,
+  pushQueryValue,
+  Query,
+  QueryBase,
+  Relation,
+  UpdateCtx,
+  UpdateData,
+  WhereArg,
+} from 'pqb';
+import { HasOneNestedInsert, HasOneNestedUpdate } from './hasOne';
+import { HasManyNestedInsert, HasManyNestedUpdate } from './hasMany';
+
+export type NestedInsertOneItem = {
+  create?: Record<string, unknown>;
+  connect?: WhereArg<QueryBase>;
+  connectOrCreate?: {
+    where: WhereArg<QueryBase>;
+    create: Record<string, unknown>;
+  };
+};
+
+export type NestedInsertManyItems = {
+  create?: Record<string, unknown>[];
+  connect?: WhereArg<QueryBase>[];
+  connectOrCreate?: {
+    where: WhereArg<QueryBase>;
+    create: Record<string, unknown>;
+  }[];
+};
+
+export type NestedInsertItem = NestedInsertOneItem | NestedInsertManyItems;
+
+export type NestedUpdateOneItem = {
+  disconnect?: boolean;
+  set?: WhereArg<QueryBase>;
+  delete?: boolean;
+  update?: UpdateData<Query>;
+  upsert?: {
+    update: UpdateData<Query>;
+    create: Record<string, unknown>;
+  };
+  create: Record<string, unknown>;
+};
+
+export type NestedUpdateManyItems = {
+  disconnect?: MaybeArray<WhereArg<QueryBase>>;
+  set?: MaybeArray<WhereArg<QueryBase>>;
+  delete?: MaybeArray<WhereArg<QueryBase>>;
+  update?: {
+    where: MaybeArray<WhereArg<QueryBase>>;
+    data: UpdateData<Query>;
+  };
+  create: Record<string, unknown>[];
+};
+
+export type NestedUpdateItem = NestedUpdateOneItem | NestedUpdateManyItems;
 
 export const getThroughRelation = (model: Query, through: string) => {
   return (model.relations as Record<string, Relation>)[through];
@@ -10,3 +67,96 @@ export const getSourceRelation = (
 ) => {
   return (throughRelation.model.relations as Record<string, Relation>)[source];
 };
+
+export const hasRelationHandleCreate = (
+  q: Query,
+  ctx: CreateCtx,
+  item: Record<string, unknown>,
+  rowIndex: number,
+  key: string,
+  primaryKey: string,
+  nestedInsert: HasOneNestedInsert | HasManyNestedInsert,
+) => {
+  const value = item[key] as NestedInsertItem;
+  if (
+    (!value.create ||
+      (Array.isArray(value.create) && value.create.length === 0)) &&
+    (!value.connect ||
+      (Array.isArray(value.connect) && value.connect.length === 0)) &&
+    (!value.connectOrCreate ||
+      (Array.isArray(value.connectOrCreate) &&
+        value.connectOrCreate.length === 0))
+  )
+    return;
+
+  const store = ctx as unknown as {
+    hasRelation?: Record<string, [number, NestedInsertItem][]>;
+  };
+
+  if (!store.hasRelation) store.hasRelation = {};
+
+  const values = [rowIndex, value] as [number, NestedInsertItem];
+
+  if (store.hasRelation[key]) {
+    store.hasRelation[key].push(values);
+    return;
+  }
+
+  q.query.wrapInTransaction = true;
+  ctx.returnTypeAll = true;
+  ctx.requiredReturning[primaryKey] = true;
+
+  const relationData = [values];
+  store.hasRelation[key] = relationData;
+
+  pushQueryValue(q, 'afterCreate', async (q: Query) => {
+    const { resultAll } = ctx;
+    return (nestedInsert as HasOneNestedInsert)(
+      q,
+      relationData.map(([rowIndex, data]) => [
+        resultAll[rowIndex],
+        data as NestedInsertOneItem,
+      ]),
+    );
+  });
+};
+
+export const hasRelationHandleUpdate = (
+  q: Query,
+  ctx: UpdateCtx,
+  set: Record<string, unknown>,
+  key: string,
+  primaryKey: string,
+  nestedUpdate: HasOneNestedUpdate | HasManyNestedUpdate,
+) => {
+  const value = set[key] as NestedUpdateItem;
+
+  if (
+    !value.set &&
+    !('upsert' in value) &&
+    (!value.disconnect ||
+      (Array.isArray(value.disconnect) && value.disconnect.length === 0)) &&
+    (!value.delete ||
+      (Array.isArray(value.delete) && value.delete.length === 0)) &&
+    (!value.update ||
+      (Array.isArray(value.update.where) && value.update.where.length === 0)) &&
+    (!value.create ||
+      (Array.isArray(value.create) && value.create.length === 0))
+  )
+    return;
+
+  if (!q.query.select?.includes('*') && !q.query.select?.includes(primaryKey)) {
+    q._select(primaryKey);
+  }
+
+  q.query.wrapInTransaction = true;
+  ctx.returnTypeAll = true;
+
+  pushQueryValue(q, 'afterUpdate', (q: Query) => {
+    return (nestedUpdate as HasOneNestedUpdate)(
+      q,
+      ctx.resultAll,
+      value as NestedUpdateOneItem,
+    );
+  });
+};