orchid-orm 1.3.15 → 1.4.16

package/src/relations/relations.ts

@@ -1,6 +1,6 @@
 import { BelongsTo, BelongsToInfo, makeBelongsToMethod } from './belongsTo';
 import { HasOne, HasOneInfo, makeHasOneMethod } from './hasOne';
-import { DbModel, Model, ModelClass, ModelClasses } from '../model';
+import { DbTable, Table, TableClass, TableClasses } from '../table';
 import { OrchidORM } from '../orm';
 import {
   Query,
@@ -13,6 +13,7 @@ import {
   defaultsKey,
   relationQueryKey,
   EmptyObject,
+  VirtualColumn,
 } from 'pqb';
 import { HasMany, HasManyInfo, makeHasManyMethod } from './hasMany';
 import {
@@ -25,7 +26,7 @@ import { getSourceRelation, getThroughRelation } from './utils';
 export interface RelationThunkBase {
   type: string;
   returns: 'one' | 'many';
-  fn(): ModelClass;
+  fn(): TableClass;
   options: BaseRelation['options'];
 }
 
@@ -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;
@@ -45,16 +45,16 @@ export type RelationData = {
 };
 
 export type Relation<
-  T extends Model,
+  T extends Table,
   Relations extends RelationThunks,
   K extends keyof Relations,
-  M extends Query = DbModel<ReturnType<Relations[K]['fn']>>,
+  M extends Query = DbTable<ReturnType<Relations[K]['fn']>>,
   Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>,
 > = {
   type: Relations[K]['type'];
   returns: Relations[K]['returns'];
   key: K;
-  model: M;
+  table: M;
   query: M;
   joinQuery(fromQuery: Query, toQuery: Query): Query;
   defaults: Info['populate'];
@@ -63,19 +63,17 @@ export type Relation<
     : M & {
         [defaultsKey]: Record<Info['populate'], true>;
       };
-  nestedInsert: BaseRelation['nestedInsert'];
-  nestedUpdate: BaseRelation['nestedUpdate'];
   primaryKey: string;
   options: Relations[K]['options'];
 };
 
-export type RelationScopeOrModel<Relation extends RelationThunkBase> =
+export type RelationScopeOrTable<Relation extends RelationThunkBase> =
   Relation['options']['scope'] extends (q: Query) => Query
     ? ReturnType<Relation['options']['scope']>
-    : DbModel<ReturnType<Relation['fn']>>;
+    : DbTable<ReturnType<Relation['fn']>>;
 
 export type RelationInfo<
-  T extends Model = Model,
+  T extends Table = Table,
   Relations extends RelationThunks = RelationThunks,
   Relation extends RelationThunk = RelationThunk,
 > = Relation extends BelongsTo
@@ -89,11 +87,11 @@ export type RelationInfo<
   : never;
 
 export type MapRelation<
-  T extends Model,
+  T extends Table,
   Relations extends RelationThunks,
   RelationName extends keyof Relations,
   Relation extends RelationThunk = Relations[RelationName],
-  RelatedQuery extends Query = RelationScopeOrModel<Relation>,
+  RelatedQuery extends Query = RelationScopeOrTable<Relation>,
   Info extends {
     params: Record<string, unknown>;
     populate: string;
@@ -116,7 +114,7 @@ export type MapRelation<
   Info['chainedDelete']
 >;
 
-export type MapRelations<T extends Model> = 'relations' extends keyof T
+export type MapRelations<T extends Table> = 'relations' extends keyof T
   ? T['relations'] extends RelationThunks
     ? {
         [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
@@ -127,48 +125,50 @@ export type MapRelations<T extends Model> = 'relations' extends keyof T
 type ApplyRelationData = {
   relationName: string;
   relation: RelationThunk;
-  dbModel: DbModel<ModelClass>;
-  otherDbModel: DbModel<ModelClass>;
+  dbTable: DbTable<TableClass>;
+  otherDbTable: DbTable<TableClass>;
 };
 
 type DelayedRelations = Map<Query, Record<string, ApplyRelationData[]>>;
 
 export const applyRelations = (
   qb: Query,
-  models: Record<string, Model>,
-  result: OrchidORM<ModelClasses>,
+  tables: Record<string, Table>,
+  result: OrchidORM<TableClasses>,
 ) => {
-  const modelsEntries = Object.entries(models);
+  const tableEntries = Object.entries(tables);
 
   const delayedRelations: DelayedRelations = new Map();
 
-  for (const modelName in models) {
-    const model = models[modelName] as Model & {
+  for (const name in tables) {
+    const table = tables[name] as Table & {
       relations?: RelationThunks;
     };
-    if (!('relations' in model) || typeof model.relations !== 'object')
+    if (!('relations' in table) || typeof table.relations !== 'object')
       continue;
 
-    const dbModel = result[modelName];
-    for (const relationName in model.relations) {
-      const relation = model.relations[relationName];
-      const otherModelClass = relation.fn();
-      const otherModel = modelsEntries.find(
-        (pair) => pair[1] instanceof otherModelClass,
+    const dbTable = result[name];
+    for (const relationName in table.relations) {
+      const relation = table.relations[relationName];
+      const otherTableClass = relation.fn();
+      const otherTable = tableEntries.find(
+        (pair) => pair[1] instanceof otherTableClass,
       );
-      if (!otherModel) {
-        throw new Error(`Cannot find model for class ${otherModelClass.name}`);
+      if (!otherTable) {
+        throw new Error(
+          `Cannot find table class for class ${otherTableClass.name}`,
+        );
       }
-      const otherModelName = otherModel[0];
-      const otherDbModel = result[otherModelName];
-      if (!otherDbModel)
-        throw new Error(`Cannot find model by name ${otherModelName}`);
+      const otherTableName = otherTable[0];
+      const otherDbTable = result[otherTableName];
+      if (!otherDbTable)
+        throw new Error(`Cannot find table class by name ${otherTableName}`);
 
       const data: ApplyRelationData = {
         relationName,
         relation,
-        dbModel,
-        otherDbModel,
+        dbTable,
+        otherDbTable,
       };
 
       const options = relation.options as { through?: string; source?: string };
@@ -176,9 +176,9 @@ export const applyRelations = (
         typeof options.through === 'string' &&
         typeof options.source === 'string'
       ) {
-        const throughRelation = getThroughRelation(dbModel, options.through);
+        const throughRelation = getThroughRelation(dbTable, options.through);
         if (!throughRelation) {
-          delayRelation(delayedRelations, dbModel, options.through, data);
+          delayRelation(delayedRelations, dbTable, options.through, data);
           continue;
         }
 
@@ -189,7 +189,7 @@ export const applyRelations = (
         if (!sourceRelation) {
           delayRelation(
             delayedRelations,
-            throughRelation.model,
+            throughRelation.table,
             options.source,
             data,
           );
@@ -209,17 +209,17 @@ export const applyRelations = (
       for (const item of value[key]) {
         const { relation } = item;
 
-        if (item.dbModel.relations[item.relationName as never]) continue;
+        if (item.dbTable.relations[item.relationName as never]) continue;
 
-        const as = item.dbModel.definedAs;
+        const as = item.dbTable.definedAs;
         let message = `Cannot define a \`${item.relationName}\` relation on \`${as}\``;
-        const model = result[as];
+        const table = result[as];
 
         const { through, source } = relation.options as {
           through: string;
           source: string;
         };
-        const throughRel = model.relations[
+        const throughRel = table.relations[
           through as never
         ] as unknown as BaseRelation;
 
@@ -228,10 +228,10 @@ export const applyRelations = (
         } else if (
           source &&
           throughRel &&
-          !throughRel.model.relations[source as never]
+          !throughRel.table.relations[source as never]
         ) {
           message += `: cannot find \`${source}\` relation in \`${
-            (throughRel.model as DbModel<ModelClass>).definedAs
+            (throughRel.table as DbTable<TableClass>).definedAs
           }\` required by the \`source\` option`;
         }
 
@@ -243,50 +243,56 @@ export const applyRelations = (
 
 const delayRelation = (
   delayedRelations: DelayedRelations,
-  model: Query,
+  table: Query,
   relationName: string,
   data: ApplyRelationData,
 ) => {
-  let modelRelations = delayedRelations.get(model);
-  if (!modelRelations) {
-    modelRelations = {};
-    delayedRelations.set(model, modelRelations);
+  let tableRelations = delayedRelations.get(table);
+  if (!tableRelations) {
+    tableRelations = {};
+    delayedRelations.set(table, tableRelations);
   }
-  if (modelRelations[relationName]) {
-    modelRelations[relationName].push(data);
+  if (tableRelations[relationName]) {
+    tableRelations[relationName].push(data);
   } else {
-    modelRelations[relationName] = [data];
+    tableRelations[relationName] = [data];
   }
 };
 
 const applyRelation = (
   qb: Query,
-  { relationName, relation, dbModel, otherDbModel }: ApplyRelationData,
+  { relationName, relation, dbTable, otherDbTable }: ApplyRelationData,
   delayedRelations: DelayedRelations,
 ) => {
   const query = (
     relation.options.scope
-      ? relation.options.scope(otherDbModel)
-      : (otherDbModel as unknown as QueryWithTable)
+      ? relation.options.scope(otherDbTable)
+      : (otherDbTable as unknown as QueryWithTable)
   ).as(relationName);
 
   const definedAs = (query as unknown as { definedAs?: string }).definedAs;
   if (!definedAs) {
     throw new Error(
-      `Model for table ${query.table} is not attached to db instance`,
+      `Table class for table ${query.table} is not attached to db instance`,
     );
   }
 
   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);
+    data = makeHasOneMethod(dbTable, relation, relationName, query);
   } else if (type === 'hasMany') {
-    data = makeHasManyMethod(dbModel, relation, relationName, query);
+    data = makeHasManyMethod(dbTable, relation, relationName, query);
   } else if (type === 'hasAndBelongsToMany') {
-    data = makeHasAndBelongsToManyMethod(dbModel, qb, relation, query);
+    data = makeHasAndBelongsToManyMethod(
+      dbTable,
+      qb,
+      relation,
+      relationName,
+      query,
+    );
   } else {
     throw new Error(`Unknown relation type ${type}`);
   }
@@ -295,50 +301,52 @@ const applyRelation = (
     query._take();
   }
 
-  makeRelationQuery(dbModel, definedAs, relationName, data);
+  if (data.virtualColumn) {
+    dbTable.shape[relationName] = data.virtualColumn;
+  }
+
+  makeRelationQuery(dbTable, definedAs, relationName, data);
 
-  (dbModel.relations as Record<string, unknown>)[relationName] = {
+  (dbTable.relations as Record<string, unknown>)[relationName] = {
     type,
     key: relationName,
-    model: otherDbModel,
+    table: otherDbTable,
     query,
-    nestedInsert: data.nestedInsert,
-    nestedUpdate: data.nestedUpdate,
     joinQuery: data.joinQuery,
     primaryKey: data.primaryKey,
     options: relation.options,
   };
 
-  const modelRelations = delayedRelations.get(dbModel);
-  if (!modelRelations) return;
+  const tableRelations = delayedRelations.get(dbTable);
+  if (!tableRelations) return;
 
-  modelRelations[relationName]?.forEach((data) => {
+  tableRelations[relationName]?.forEach((data) => {
     applyRelation(qb, data, delayedRelations);
   });
 };
 
 const makeRelationQuery = (
-  model: Query,
+  table: Query,
   definedAs: string,
   relationName: string,
   data: RelationData,
 ) => {
-  Object.defineProperty(model, relationName, {
+  Object.defineProperty(table, relationName, {
     get() {
-      const toModel = this.db[definedAs].as(relationName) as Query;
+      const toTable = this.db[definedAs].as(relationName) as Query;
 
       if (data.returns === 'one') {
-        toModel._take();
+        toTable._take();
       }
 
       const query = this.isSubQuery
-        ? toModel
-        : toModel._whereExists(data.reverseJoin(this, toModel), (q) => q);
+        ? toTable
+        : toTable._whereExists(data.reverseJoin(this, toTable), (q) => q);
 
       query.query[relationQueryKey] = {
         relationName,
         sourceQuery: this,
-        relationQuery: toModel,
+        relationQuery: toTable,
         joinQuery: data.joinQuery,
       };
 

package/src/relations/utils.ts

@@ -1,12 +1,162 @@
-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 const getThroughRelation = (model: Query, through: string) => {
-  return (model.relations as Record<string, Relation>)[through];
+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 = (table: Query, through: string) => {
+  return (table.relations as Record<string, Relation>)[through];
 };
 
 export const getSourceRelation = (
   throughRelation: Relation,
   source: string,
 ) => {
-  return (throughRelation.model.relations as Record<string, Relation>)[source];
+  return (throughRelation.table.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,
+    );
+  });
 };

package/src/repo.test.ts

@@ -1,63 +1,63 @@
 import { orchidORM } from './orm';
 import { pgConfig } from './test-utils/test-db';
-import { createModel } from './model';
+import { createBaseTable } from './table';
 import { assertType, expectSql } from './test-utils/test-utils';
 import { columnTypes, QueryReturnType } from 'pqb';
 import { createRepo } from './repo';
 
-const Model = createModel({ columnTypes });
+const BaseTable = createBaseTable({ columnTypes });
 
-class SomeModel extends Model {
+class SomeTable extends BaseTable {
   table = 'someTable';
   columns = this.setColumns((t) => ({
     id: t.serial().primaryKey(),
-    name: t.text(),
+    name: t.text(0, 100),
   }));
 
   relations = {
-    otherModel: this.hasMany(() => OtherModel, {
+    other: this.hasMany(() => OtherTable, {
       primaryKey: 'id',
       foreignKey: 'someId',
     }),
   };
 }
 
-class OtherModel extends Model {
+class OtherTable extends BaseTable {
   table = 'otherTable';
   columns = this.setColumns((t) => ({
     id: t.serial().primaryKey(),
-    someId: t.integer().foreignKey(() => SomeModel, 'id'),
-    anotherId: t.integer().foreignKey(() => AnotherModel, 'id'),
+    someId: t.integer().foreignKey(() => SomeTable, 'id'),
+    anotherId: t.integer().foreignKey(() => AnotherTable, 'id'),
   }));
 
   relations = {
-    someModel: this.belongsTo(() => SomeModel, {
+    some: this.belongsTo(() => SomeTable, {
       primaryKey: 'id',
       foreignKey: 'someId',
     }),
-    anotherModel: this.belongsTo(() => AnotherModel, {
+    another: this.belongsTo(() => AnotherTable, {
       primaryKey: 'id',
       foreignKey: 'anotherId',
     }),
   };
 }
 
-class AnotherModel extends Model {
-  table = 'anotherModel';
+class AnotherTable extends BaseTable {
+  table = 'another';
   columns = this.setColumns((t) => ({
     id: t.serial().primaryKey(),
   }));
 }
 
 const db = orchidORM(pgConfig, {
-  someModel: SomeModel,
-  otherModel: OtherModel,
-  anotherModel: AnotherModel,
+  some: SomeTable,
+  other: OtherTable,
+  another: AnotherTable,
 });
 
 describe('createRepo', () => {
   describe('queryMethods', () => {
-    const repo = createRepo(db.someModel, {
+    const repo = createRepo(db.some, {
       queryMethods: {
         one(q) {
           return q.select('id');
@@ -71,7 +71,7 @@ describe('createRepo', () => {
       },
     });
 
-    it('should accept user defined methods and allow to use them on the model with chaining', async () => {
+    it('should accept user defined methods and allow to use them on the table with chaining', async () => {
       const q = repo.one().two().three(123).take();
 
       assertType<Awaited<typeof q>, { id: number; name: string }>();
@@ -89,13 +89,13 @@ describe('createRepo', () => {
     });
 
     it('should have custom methods on relation queries inside of select', async () => {
-      const q = db.otherModel.select('id', {
-        someModel: (q) => repo(q.someModel).one().two().three(123),
+      const q = db.other.select('id', {
+        some: (q) => repo(q.some).one().two().three(123),
       });
 
       assertType<
         Awaited<typeof q>,
-        { id: number; someModel: { id: number; name: string } | null }[]
+        { id: number; some: { id: number; name: string } | null }[]
       >();
 
       expectSql(
@@ -106,13 +106,13 @@ describe('createRepo', () => {
             (
               SELECT row_to_json("t".*)
               FROM (
-                SELECT "someModel"."id", "someModel"."name"
-                FROM "someTable" AS "someModel"
-                WHERE "someModel"."id" = $1
-                  AND "someModel"."id" = "otherTable"."someId"
+                SELECT "some"."id", "some"."name"
+                FROM "someTable" AS "some"
+                WHERE "some"."id" = $1
+                  AND "some"."id" = "otherTable"."someId"
                 LIMIT $2
               ) AS "t"
-            ) AS "someModel"
+            ) AS "some"
           FROM "otherTable"
         `,
         [123, 1],
@@ -121,7 +121,7 @@ describe('createRepo', () => {
   });
 
   describe('queryOneMethods', () => {
-    const repo = createRepo(db.someModel, {
+    const repo = createRepo(db.some, {
       queryOneMethods: {
         one(q) {
           const type: Exclude<QueryReturnType, 'all'> = q.returnType;
@@ -140,7 +140,7 @@ describe('createRepo', () => {
   });
 
   describe('queryWithWhereMethods', () => {
-    const repo = createRepo(db.someModel, {
+    const repo = createRepo(db.some, {
       queryWithWhereMethods: {
         one(q) {
           const hasWhere: true = q.hasWhere;
@@ -161,7 +161,7 @@ describe('createRepo', () => {
   });
 
   describe('queryOneWithWhere', () => {
-    const repo = createRepo(db.someModel, {
+    const repo = createRepo(db.some, {
       queryOneWithWhereMethods: {
         one(q) {
           const type: Exclude<QueryReturnType, 'all'> = q.returnType;
@@ -185,7 +185,7 @@ describe('createRepo', () => {
   });
 
   describe('methods', () => {
-    const repo = createRepo(db.someModel, {
+    const repo = createRepo(db.some, {
       methods: {
         one(a: number, b: string) {
           return a + b;