orchid-orm 1.3.15 → 1.4.16

package/src/orm.ts

@@ -8,12 +8,12 @@ import {
   anyShape,
   DbTableOptions,
 } from 'pqb';
-import { DbModel, Model, ModelClasses } from './model';
+import { DbTable, Table, TableClasses } from './table';
 import { applyRelations } from './relations/relations';
 import { transaction } from './transaction';
 
-export type OrchidORM<T extends ModelClasses> = {
-  [K in keyof T]: DbModel<T[K]>;
+export type OrchidORM<T extends TableClasses> = {
+  [K in keyof T]: DbTable<T[K]>;
 } & {
   $transaction: typeof transaction;
   $adapter: Adapter;
@@ -21,7 +21,7 @@ export type OrchidORM<T extends ModelClasses> = {
   $close(): Promise<void>;
 };
 
-export const orchidORM = <T extends ModelClasses>(
+export const orchidORM = <T extends TableClasses>(
   {
     log,
     logger,
@@ -33,7 +33,7 @@ export const orchidORM = <T extends ModelClasses>(
       autoPreparedStatements?: boolean;
       noPrimaryKey?: NoPrimaryKeyOption;
     },
-  models: T,
+  tables: T,
 ): OrchidORM<T> => {
   const adapter = 'adapter' in options ? options.adapter : new Adapter(options);
   const commonOptions = {
@@ -57,42 +57,42 @@ export const orchidORM = <T extends ModelClasses>(
     $adapter: adapter,
     $queryBuilder: qb,
     $close: () => adapter.close(),
-  } as unknown as OrchidORM<ModelClasses>;
+  } as unknown as OrchidORM<TableClasses>;
 
-  const modelInstances: Record<string, Model> = {};
+  const tableInstances: Record<string, Table> = {};
 
-  for (const key in models) {
+  for (const key in tables) {
     if (key[0] === '$') {
-      throw new Error(`Model name must not start with $`);
+      throw new Error(`Table class name must not start with $`);
     }
 
-    const model = new models[key]();
-    modelInstances[key] = model;
+    const table = new tables[key]();
+    tableInstances[key] = table;
 
     const options: DbTableOptions = {
       ...commonOptions,
-      schema: model.schema,
+      schema: table.schema,
     };
 
-    if (model.noPrimaryKey) options.noPrimaryKey = 'ignore';
+    if (table.noPrimaryKey) options.noPrimaryKey = 'ignore';
 
-    const dbModel = new Db(
+    const dbTable = new Db(
       adapter,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       qb as any,
-      model.table,
-      model.columns.shape,
-      model.columnTypes,
+      table.table,
+      table.columns.shape,
+      table.columnTypes,
       options,
     );
 
-    (dbModel as unknown as { definedAs: string }).definedAs = key;
-    (dbModel as unknown as { db: unknown }).db = result;
+    (dbTable as unknown as { definedAs: string }).definedAs = key;
+    (dbTable as unknown as { db: unknown }).db = result;
 
-    (result as Record<string, unknown>)[key] = dbModel;
+    (result as Record<string, unknown>)[key] = dbTable;
   }
 
-  applyRelations(qb, modelInstances, result);
+  applyRelations(qb, tableInstances, result);
 
   return result as unknown as OrchidORM<T>;
 };

package/src/relations/belongsTo.test.ts

@@ -10,7 +10,7 @@ import {
   useTestDatabase,
 } from '../test-utils/test-utils';
 import { RelationQuery } from 'pqb';
-import { User } from '../test-utils/test-models';
+import { User } from '../test-utils/test-tables';
 
 describe('belongsTo', () => {
   useTestDatabase();

package/src/relations/belongsTo.ts

@@ -1,16 +1,20 @@
-import { Model } from '../model';
+import { Table } from '../table';
 import {
   addQueryOn,
-  BelongsToNestedInsert,
-  BelongsToNestedUpdate,
   BelongsToRelation,
+  CreateCtx,
+  InsertQueryData,
   isQueryReturnsAll,
+  pushQueryValue,
   Query,
   QueryBase,
+  UpdateCtx,
+  VirtualColumn,
   WhereArg,
   WhereResult,
 } from 'pqb';
 import { RelationData, RelationThunkBase } from './relations';
+import { NestedInsertOneItem, NestedUpdateOneItem } from './utils';
 
 export interface BelongsTo extends RelationThunkBase {
   type: 'belongsTo';
@@ -19,7 +23,7 @@ export interface BelongsTo extends RelationThunkBase {
 }
 
 export type BelongsToInfo<
-  T extends Model,
+  T extends Table,
   Relation extends BelongsTo,
   FK extends string = Relation['options']['foreignKey'],
 > = {
@@ -29,219 +33,320 @@ export type BelongsToInfo<
   chainedDelete: false;
 };
 
+type State = {
+  query: Query;
+  primaryKey: string;
+  foreignKey: string;
+};
+
+type BelongsToNestedInsert = (
+  query: Query,
+  relationData: NestedInsertOneItem[],
+) => Promise<Record<string, unknown>[]>;
+
+type BelongsToNestedUpdate = (
+  q: Query,
+  update: Record<string, unknown>,
+  params: NestedUpdateOneItem,
+  state: {
+    updateLater?: Record<string, unknown>;
+    updateLaterPromises?: Promise<void>[];
+  },
+) => boolean;
+
+class BelongsToVirtualColumn extends VirtualColumn {
+  private readonly nestedInsert: BelongsToNestedInsert;
+  private readonly nestedUpdate: BelongsToNestedUpdate;
+
+  constructor(private key: string, private state: State) {
+    super();
+    this.nestedInsert = nestedInsert(this.state);
+    this.nestedUpdate = nestedUpdate(this.state);
+  }
+
+  create(
+    q: Query,
+    ctx: CreateCtx,
+    item: Record<string, unknown>,
+    rowIndex: number,
+  ) {
+    const {
+      key,
+      state: { foreignKey, primaryKey },
+    } = this;
+
+    let columnIndex = ctx.columns.get(foreignKey);
+    if (columnIndex === undefined) {
+      ctx.columns.set(foreignKey, (columnIndex = ctx.columns.size));
+    }
+
+    const store = ctx as unknown as {
+      belongsTo?: Record<string, [number, number, unknown][]>;
+    };
+
+    if (!store.belongsTo) store.belongsTo = {};
+
+    const values = [rowIndex, columnIndex, item[key]] as [
+      number,
+      number,
+      unknown,
+    ];
+
+    if (store.belongsTo[key]) {
+      store.belongsTo[key].push(values);
+      return;
+    }
+
+    const relationData = [values];
+    store.belongsTo[key] = relationData;
+    q.query.wrapInTransaction = true;
+
+    pushQueryValue(q, 'beforeCreate', async (q: Query) => {
+      const inserted = await this.nestedInsert(
+        q,
+        relationData.map(([, , data]) => data as NestedInsertOneItem),
+      );
+
+      const { values } = q.query as InsertQueryData;
+      relationData.forEach(([rowIndex, columnIndex], index) => {
+        (values as unknown[][])[rowIndex][columnIndex] =
+          inserted[index][primaryKey];
+      });
+    });
+  }
+
+  update(q: Query, ctx: UpdateCtx, set: Record<string, unknown>) {
+    q.query.wrapInTransaction = true;
+
+    const data = set[this.key] as NestedUpdateOneItem;
+    if (this.nestedUpdate(q, set, data, ctx)) {
+      ctx.willSetKeys = true;
+    }
+  }
+}
+
 export const makeBelongsToMethod = (
   relation: BelongsTo,
+  relationName: string,
   query: Query,
 ): RelationData => {
   const { primaryKey, foreignKey } = relation.options;
+  const state: State = { query, primaryKey, foreignKey };
 
   return {
     returns: 'one',
     method: (params: Record<string, unknown>) => {
       return query.findBy({ [primaryKey]: params[foreignKey] });
     },
-    nestedInsert: (async (q, data) => {
-      const connectOrCreate = data.filter(
-        (
-          item,
-        ): item is {
-          connectOrCreate: {
-            where: WhereArg<QueryBase>;
-            create: Record<string, unknown>;
-          };
-        } => Boolean(item.connectOrCreate),
-      );
+    virtualColumn: new BelongsToVirtualColumn(relationName, state),
+    joinQuery(fromQuery, toQuery) {
+      return addQueryOn(toQuery, fromQuery, toQuery, primaryKey, foreignKey);
+    },
+    reverseJoin(fromQuery, toQuery) {
+      return addQueryOn(fromQuery, toQuery, fromQuery, foreignKey, primaryKey);
+    },
+    primaryKey,
+  };
+};
 
-      const t = query.transacting(q);
+const nestedInsert = ({ query, primaryKey }: State) => {
+  return (async (q, data) => {
+    const connectOrCreate = data.filter(
+      (
+        item,
+      ): item is {
+        connectOrCreate: {
+          where: WhereArg<QueryBase>;
+          create: Record<string, unknown>;
+        };
+      } => Boolean(item.connectOrCreate),
+    );
 
-      let connectOrCreated: unknown[];
-      if (connectOrCreate.length) {
-        connectOrCreated = await Promise.all(
-          connectOrCreate.map((item) =>
-            t.findBy(item.connectOrCreate.where)._takeOptional(),
-          ),
-        );
-      } else {
-        connectOrCreated = [];
-      }
+    const t = query.transacting(q);
 
-      let connectOrCreatedI = 0;
-      const create = data.filter(
-        (
-          item,
-        ): item is
-          | {
-              create: Record<string, unknown>;
-            }
-          | {
-              connectOrCreate: {
-                where: WhereArg<QueryBase>;
-                create: Record<string, unknown>;
-              };
-            } => {
-          if (item.connectOrCreate) {
-            return !connectOrCreated[connectOrCreatedI++];
-          } else {
-            return Boolean(item.create);
-          }
-        },
+    let connectOrCreated: unknown[];
+    if (connectOrCreate.length) {
+      connectOrCreated = await Promise.all(
+        connectOrCreate.map((item) =>
+          t.findBy(item.connectOrCreate.where)._takeOptional(),
+        ),
       );
+    } else {
+      connectOrCreated = [];
+    }
 
-      let created: unknown[];
-      if (create.length) {
-        created = (await t
-          .select(primaryKey)
-          ._createMany(
-            create.map((item) =>
-              'create' in item ? item.create : item.connectOrCreate.create,
-            ),
-          )) as unknown[];
-      } else {
-        created = [];
-      }
+    let connectOrCreatedI = 0;
+    const create = data.filter(
+      (
+        item,
+      ): item is
+        | {
+            create: Record<string, unknown>;
+          }
+        | {
+            connectOrCreate: {
+              where: WhereArg<QueryBase>;
+              create: Record<string, unknown>;
+            };
+          } => {
+        if (item.connectOrCreate) {
+          return !connectOrCreated[connectOrCreatedI++];
+        } else {
+          return Boolean(item.create);
+        }
+      },
+    );
 
-      const connect = data.filter(
-        (
-          item,
-        ): item is {
-          connect: WhereArg<QueryBase>;
-        } => Boolean(item.connect),
-      );
+    let created: unknown[];
+    if (create.length) {
+      created = (await t
+        .select(primaryKey)
+        ._createMany(
+          create.map((item) =>
+            'create' in item ? item.create : item.connectOrCreate.create,
+          ),
+        )) as unknown[];
+    } else {
+      created = [];
+    }
 
-      let connected: unknown[];
-      if (connect.length) {
-        connected = await Promise.all(
-          connect.map((item) => t.findBy(item.connect)._take()),
-        );
-      } else {
-        connected = [];
-      }
+    const connect = data.filter(
+      (
+        item,
+      ): item is {
+        connect: WhereArg<QueryBase>;
+      } => Boolean(item.connect),
+    );
 
-      let createdI = 0;
-      let connectedI = 0;
-      connectOrCreatedI = 0;
-      return data.map((item) =>
-        item.connectOrCreate
-          ? connectOrCreated[connectOrCreatedI++] || created[createdI++]
-          : item.connect
-          ? connected[connectedI++]
-          : created[createdI++],
+    let connected: unknown[];
+    if (connect.length) {
+      connected = await Promise.all(
+        connect.map((item) => t.findBy(item.connect)._take()),
       );
-    }) as BelongsToNestedInsert,
-    nestedUpdate: ((q, update, params, state) => {
-      if (params.upsert && isQueryReturnsAll(q)) {
-        throw new Error('`upsert` option is not allowed in a batch update');
-      }
+    } else {
+      connected = [];
+    }
 
-      let idForDelete: unknown;
-
-      q._beforeUpdate(async (q) => {
-        if (params.disconnect) {
-          update[foreignKey] = null;
-        } else if (params.set) {
-          if (primaryKey in params.set) {
-            update[foreignKey] =
-              params.set[primaryKey as keyof typeof params.set];
-          } else {
-            update[foreignKey] = await query
-              .transacting(q)
-              ._findBy(params.set)
-              ._get(primaryKey);
-          }
-        } else if (params.create) {
+    let createdI = 0;
+    let connectedI = 0;
+    connectOrCreatedI = 0;
+    return data.map((item) =>
+      item.connectOrCreate
+        ? connectOrCreated[connectOrCreatedI++] || created[createdI++]
+        : item.connect
+        ? connected[connectedI++]
+        : created[createdI++],
+    ) as Record<string, unknown>[];
+  }) as BelongsToNestedInsert;
+};
+
+const nestedUpdate = ({ query, primaryKey, foreignKey }: State) => {
+  return ((q, update, params, state) => {
+    if (params.upsert && isQueryReturnsAll(q)) {
+      throw new Error('`upsert` option is not allowed in a batch update');
+    }
+
+    let idForDelete: unknown;
+
+    q._beforeUpdate(async (q) => {
+      if (params.disconnect) {
+        update[foreignKey] = null;
+      } else if (params.set) {
+        if (primaryKey in params.set) {
+          update[foreignKey] =
+            params.set[primaryKey as keyof typeof params.set];
+        } else {
           update[foreignKey] = await query
             .transacting(q)
-            ._get(primaryKey)
-            ._create(params.create);
-        } else if (params.delete) {
-          const selectQuery = q.transacting(q);
-          selectQuery.query.type = undefined;
-          idForDelete = await selectQuery._getOptional(foreignKey);
-          update[foreignKey] = null;
+            ._findBy(params.set)
+            ._get(primaryKey);
         }
-      });
+      } else if (params.create) {
+        update[foreignKey] = await query
+          .transacting(q)
+          ._get(primaryKey)
+          ._create(params.create);
+      } else if (params.delete) {
+        const selectQuery = q.transacting(q);
+        selectQuery.query.type = undefined;
+        idForDelete = await selectQuery._getOptional(foreignKey);
+        update[foreignKey] = null;
+      }
+    });
 
-      const { upsert } = params;
-      if (upsert || params.update || params.delete) {
-        if (
-          !q.query.select?.includes('*') &&
-          !q.query.select?.includes(foreignKey)
-        ) {
-          q._select(foreignKey);
-        }
+    const { upsert } = params;
+    if (upsert || params.update || params.delete) {
+      if (
+        !q.query.select?.includes('*') &&
+        !q.query.select?.includes(foreignKey)
+      ) {
+        q._select(foreignKey);
       }
+    }
 
-      if (upsert) {
-        if (!state.updateLater) {
-          state.updateLater = {};
-          state.updateLaterPromises = [];
-        }
+    if (upsert) {
+      if (!state.updateLater) {
+        state.updateLater = {};
+        state.updateLaterPromises = [];
+      }
 
-        const { handleResult } = q.query;
-        q.query.handleResult = async (q, queryResult) => {
-          const data = (await handleResult(q, queryResult)) as Record<
-            string,
-            unknown
-          >[];
+      const { handleResult } = q.query;
+      q.query.handleResult = async (q, queryResult) => {
+        const data = (await handleResult(q, queryResult)) as Record<
+          string,
+          unknown
+        >[];
 
-          const id = data[0][foreignKey];
-          if (id !== null) {
-            await query
+        const id = data[0][foreignKey];
+        if (id !== null) {
+          await query
+            .transacting(q)
+            ._findBy({ [primaryKey]: id })
+            ._update<WhereResult<Query>>(upsert.update);
+        } else {
+          (state.updateLaterPromises as Promise<void>[]).push(
+            query
               .transacting(q)
-              ._findBy({ [primaryKey]: id })
-              ._update<WhereResult<Query>>(upsert.update);
-          } else {
-            (state.updateLaterPromises as Promise<void>[]).push(
-              query
-                .transacting(q)
-                ._select(primaryKey)
-                ._create(upsert.create)
-                .then((result) => {
-                  (state.updateLater as Record<string, unknown>)[foreignKey] = (
-                    result as Record<string, unknown>
-                  )[primaryKey];
-                }) as unknown as Promise<void>,
-            );
-          }
+              ._select(primaryKey)
+              ._create(upsert.create)
+              .then((result) => {
+                (state.updateLater as Record<string, unknown>)[foreignKey] = (
+                  result as Record<string, unknown>
+                )[primaryKey];
+              }) as unknown as Promise<void>,
+          );
+        }
 
-          return data;
-        };
-      } else if (params.delete || params.update) {
-        q._afterQuery(async (q, data) => {
-          const id = params.delete
-            ? idForDelete
-            : Array.isArray(data)
-            ? data.length === 0
-              ? null
-              : {
-                  in: data
-                    .map((item) => item[foreignKey])
-                    .filter((id) => id !== null),
-                }
-            : (data as Record<string, unknown>)[foreignKey];
-
-          if (id !== undefined && id !== null) {
-            const t = query.transacting(q)._findBy({
-              [primaryKey]: id,
-            });
-
-            if (params.delete) {
-              await t._delete();
-            } else if (params.update) {
-              await t._update<WhereResult<Query>>(params.update);
-            }
+        return data;
+      };
+    } else if (params.delete || params.update) {
+      q._afterQuery(async (q, data) => {
+        const id = params.delete
+          ? idForDelete
+          : Array.isArray(data)
+          ? data.length === 0
+            ? null
+            : {
+                in: data
+                  .map((item) => item[foreignKey])
+                  .filter((id) => id !== null),
+              }
+          : (data as Record<string, unknown>)[foreignKey];
+
+        if (id !== undefined && id !== null) {
+          const t = query.transacting(q)._findBy({
+            [primaryKey]: id,
+          });
+
+          if (params.delete) {
+            await t._delete();
+          } else if (params.update) {
+            await t._update<WhereResult<Query>>(params.update);
           }
-        });
-      }
+        }
+      });
+    }
 
-      return !params.update && !params.upsert;
-    }) as BelongsToNestedUpdate,
-    joinQuery(fromQuery, toQuery) {
-      return addQueryOn(toQuery, fromQuery, toQuery, primaryKey, foreignKey);
-    },
-    reverseJoin(fromQuery, toQuery) {
-      return addQueryOn(fromQuery, toQuery, fromQuery, foreignKey, primaryKey);
-    },
-    primaryKey,
-  };
+    return !params.update && !params.upsert;
+  }) as BelongsToNestedUpdate;
 };

package/src/relations/hasAndBelongsToMany.test.ts

@@ -9,7 +9,7 @@ import {
   useRelationCallback,
 } from '../test-utils/test-utils';
 import { RelationQuery, Sql, TransactionAdapter } from 'pqb';
-import { Chat, User } from '../test-utils/test-models';
+import { Chat, User } from '../test-utils/test-tables';
 
 describe('hasAndBelongsToMany', () => {
   useTestDatabase();