orchid-orm 0.0.1

package/src/relations/hasOne.ts

@@ -0,0 +1,278 @@
+import {
+  addQueryOn,
+  getQueryAs,
+  HasOneNestedInsert,
+  HasOneNestedUpdate,
+  HasOneRelation,
+  InsertQueryData,
+  isQueryReturnsAll,
+  JoinCallback,
+  Query,
+  QueryBase,
+  WhereArg,
+  WhereResult,
+} from 'pqb';
+import { Model } from '../model';
+import {
+  RelationData,
+  RelationInfo,
+  RelationThunkBase,
+  RelationThunks,
+} from './relations';
+import { getSourceRelation, getThroughRelation } from './utils';
+
+export interface HasOne extends RelationThunkBase {
+  type: 'hasOne';
+  returns: 'one';
+  options: HasOneRelation['options'];
+}
+
+export type HasOneInfo<
+  T extends Model,
+  Relations extends RelationThunks,
+  Relation extends HasOne,
+> = {
+  params: Relation['options'] extends { primaryKey: string }
+    ? Record<
+        Relation['options']['primaryKey'],
+        T['columns']['shape'][Relation['options']['primaryKey']]['type']
+      >
+    : Relation['options'] extends { through: string }
+    ? RelationInfo<
+        T,
+        Relations,
+        Relations[Relation['options']['through']]
+      >['params']
+    : never;
+  populate: Relation['options'] extends { foreignKey: string }
+    ? Relation['options']['foreignKey']
+    : never;
+  chainedCreate: Relation['options'] extends { primaryKey: string }
+    ? true
+    : false;
+  chainedDelete: true;
+};
+
+export const makeHasOneMethod = (
+  model: Query,
+  relation: HasOne,
+  relationName: string,
+  query: Query,
+): RelationData => {
+  if (relation.options.required) {
+    query._take();
+  } else {
+    query._takeOptional();
+  }
+
+  if ('through' in relation.options) {
+    const { through, source } = relation.options;
+
+    type ModelWithQueryMethod = Record<
+      string,
+      (params: Record<string, unknown>) => Query
+    >;
+
+    const throughRelation = getThroughRelation(model, through);
+    const sourceRelation = getSourceRelation(throughRelation, source);
+    const sourceQuery = sourceRelation
+      .joinQuery(throughRelation.query, sourceRelation.query)
+      .as(relationName);
+
+    const whereExistsCallback = () => sourceQuery;
+
+    return {
+      returns: 'one',
+      method: (params: Record<string, unknown>) => {
+        const throughQuery = (model as unknown as ModelWithQueryMethod)[
+          through
+        ](params);
+
+        return query.whereExists<Query, Query>(
+          throughQuery,
+          whereExistsCallback as unknown as JoinCallback<Query, Query>,
+        );
+      },
+      nestedInsert: undefined,
+      nestedUpdate: undefined,
+      joinQuery(fromQuery, toQuery) {
+        return toQuery.whereExists<Query, Query>(
+          throughRelation.joinQuery(fromQuery, throughRelation.query),
+          (() => {
+            const as = getQueryAs(toQuery);
+            return sourceRelation.joinQuery(
+              throughRelation.query,
+              sourceRelation.query.as(as),
+            );
+          }) as unknown as JoinCallback<Query, Query>,
+        );
+      },
+      reverseJoin(fromQuery, toQuery) {
+        return fromQuery.whereExists<Query, Query>(
+          throughRelation.joinQuery(fromQuery, throughRelation.query),
+          (() => {
+            const as = getQueryAs(toQuery);
+            return sourceRelation.joinQuery(
+              throughRelation.query,
+              sourceRelation.query.as(as),
+            );
+          }) as unknown as JoinCallback<Query, Query>,
+        );
+      },
+      primaryKey: sourceRelation.primaryKey,
+    };
+  }
+
+  const { primaryKey, foreignKey } = relation.options;
+
+  const fromQuerySelect = [{ selectAs: { [foreignKey]: primaryKey } }];
+
+  return {
+    returns: 'one',
+    method: (params: Record<string, unknown>) => {
+      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,
+    joinQuery(fromQuery, toQuery) {
+      return addQueryOn(toQuery, fromQuery, toQuery, foreignKey, primaryKey);
+    },
+    reverseJoin(fromQuery, toQuery) {
+      return addQueryOn(fromQuery, toQuery, fromQuery, primaryKey, foreignKey);
+    },
+    primaryKey,
+    modifyRelatedQuery(relationQuery) {
+      return (query) => {
+        const fromQuery = query.clone();
+        fromQuery.query.select = fromQuerySelect;
+        (relationQuery.query as InsertQueryData).fromQuery = fromQuery;
+      };
+    },
+  };
+};

package/src/relations/relations.test.ts

@@ -0,0 +1,37 @@
+import { db } from '../test-utils/test-db';
+import { expectSql } from '../test-utils/test-utils';
+
+describe('relations', () => {
+  it('should select multiple relations', () => {
+    const query = db.user.select({
+      profile: (q) => q.profile.where({ bio: 'bio' }),
+      messages: (q) => q.messages.where({ text: 'text' }),
+    });
+
+    expectSql(
+      query.toSql(),
+      `
+        SELECT
+          (
+            SELECT row_to_json("t".*)
+            FROM (
+              SELECT * FROM "profile"
+              WHERE "profile"."bio" = $1
+                AND "profile"."userId" = "user"."id"
+              LIMIT $2
+            ) AS "t"
+          ) AS "profile",
+          (
+            SELECT COALESCE(json_agg(row_to_json("t".*)), '[]')
+            FROM (
+              SELECT * FROM "message" AS "messages"
+              WHERE "messages"."text" = $3
+                AND "messages"."authorId" = "user"."id"
+            ) AS "t"
+          ) AS "messages"
+        FROM "user"
+      `,
+      ['bio', 1, 'text'],
+    );
+  });
+});

package/src/relations/relations.ts

@@ -0,0 +1,316 @@
+import { BelongsTo, BelongsToInfo, makeBelongsToMethod } from './belongsTo';
+import { HasOne, HasOneInfo, makeHasOneMethod } from './hasOne';
+import { DbModel, Model, ModelClass, ModelClasses } from '../model';
+import { OrchidORM } from '../orm';
+import {
+  Query,
+  QueryWithTable,
+  RelationQuery,
+  SetQueryReturnsAll,
+  SetQueryReturnsOne,
+  SetQueryReturnsOneOptional,
+  BaseRelation,
+  defaultsKey,
+  relationQueryKey,
+  EmptyObject,
+} from 'pqb';
+import { HasMany, HasManyInfo, makeHasManyMethod } from './hasMany';
+import {
+  HasAndBelongsToMany,
+  HasAndBelongsToManyInfo,
+  makeHasAndBelongsToManyMethod,
+} from './hasAndBelongsToMany';
+import { getSourceRelation, getThroughRelation } from './utils';
+
+export interface RelationThunkBase {
+  type: string;
+  returns: 'one' | 'many';
+  fn(): ModelClass;
+  options: BaseRelation['options'];
+}
+
+export type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
+
+export type RelationThunks = Record<string, RelationThunk>;
+
+export type RelationData = {
+  returns: 'one' | 'many';
+  method(params: Record<string, unknown>): Query;
+  nestedInsert: BaseRelation['nestedInsert'];
+  nestedUpdate: BaseRelation['nestedUpdate'];
+  joinQuery(fromQuery: Query, toQuery: Query): Query;
+  reverseJoin(fromQuery: Query, toQuery: Query): Query;
+  primaryKey: string;
+  modifyRelatedQuery?(relatedQuery: Query): (query: Query) => void;
+};
+
+export type Relation<
+  T extends Model,
+  Relations extends RelationThunks,
+  K extends keyof Relations,
+  M extends Query = DbModel<ReturnType<Relations[K]['fn']>>,
+  Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>,
+> = {
+  type: Relations[K]['type'];
+  returns: Relations[K]['returns'];
+  key: K;
+  model: M;
+  query: M;
+  joinQuery(fromQuery: Query, toQuery: Query): Query;
+  defaults: Info['populate'];
+  nestedCreateQuery: [Info['populate']] extends [never]
+    ? M
+    : M & {
+        [defaultsKey]: Record<Info['populate'], true>;
+      };
+  nestedInsert: BaseRelation['nestedInsert'];
+  nestedUpdate: BaseRelation['nestedUpdate'];
+  primaryKey: string;
+  options: Relations[K]['options'];
+};
+
+export type RelationScopeOrModel<Relation extends RelationThunkBase> =
+  Relation['options']['scope'] extends (q: Query) => Query
+    ? ReturnType<Relation['options']['scope']>
+    : DbModel<ReturnType<Relation['fn']>>;
+
+export type RelationInfo<
+  T extends Model = Model,
+  Relations extends RelationThunks = RelationThunks,
+  Relation extends RelationThunk = RelationThunk,
+> = Relation extends BelongsTo
+  ? BelongsToInfo<T, Relation>
+  : Relation extends HasOne
+  ? HasOneInfo<T, Relations, Relation>
+  : Relation extends HasMany
+  ? HasManyInfo<T, Relations, Relation>
+  : Relation extends HasAndBelongsToMany
+  ? HasAndBelongsToManyInfo<T, Relation>
+  : never;
+
+export type MapRelation<
+  T extends Model,
+  Relations extends RelationThunks,
+  RelationName extends keyof Relations,
+  Relation extends RelationThunk = Relations[RelationName],
+  RelatedQuery extends Query = RelationScopeOrModel<Relation>,
+  Info extends {
+    params: Record<string, unknown>;
+    populate: string;
+    chainedCreate: boolean;
+    chainedDelete: boolean;
+  } = RelationInfo<T, Relations, Relation>,
+> = RelationQuery<
+  RelationName,
+  Info['params'],
+  Info['populate'],
+  Relation['returns'] extends 'one'
+    ? Relation['options']['required'] extends true
+      ? SetQueryReturnsOne<RelatedQuery>
+      : SetQueryReturnsOneOptional<RelatedQuery>
+    : SetQueryReturnsAll<RelatedQuery>,
+  Relation['options']['required'] extends boolean
+    ? Relation['options']['required']
+    : false,
+  Info['chainedCreate'],
+  Info['chainedDelete']
+>;
+
+export type MapRelations<T extends Model> = 'relations' extends keyof T
+  ? T['relations'] extends RelationThunks
+    ? {
+        [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
+      }
+    : EmptyObject
+  : EmptyObject;
+
+type ApplyRelationData = {
+  relationName: string;
+  relation: RelationThunk;
+  dbModel: DbModel<ModelClass>;
+  otherDbModel: DbModel<ModelClass>;
+};
+
+type DelayedRelations = Map<Query, Record<string, ApplyRelationData[]>>;
+
+export const applyRelations = (
+  qb: Query,
+  models: Record<string, Model>,
+  result: OrchidORM<ModelClasses>,
+) => {
+  const modelsEntries = Object.entries(models);
+
+  const delayedRelations: DelayedRelations = new Map();
+
+  for (const modelName in models) {
+    const model = models[modelName] as Model & {
+      relations?: RelationThunks;
+    };
+    if (!('relations' in model) || typeof model.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,
+      );
+      if (!otherModel) {
+        throw new Error(`Cannot find model for class ${otherModelClass.name}`);
+      }
+      const otherModelName = otherModel[0];
+      const otherDbModel = result[otherModelName];
+      if (!otherDbModel)
+        throw new Error(`Cannot find model by name ${otherModelName}`);
+
+      const data: ApplyRelationData = {
+        relationName,
+        relation,
+        dbModel,
+        otherDbModel,
+      };
+
+      const options = relation.options as { through?: string; source?: string };
+      if (
+        typeof options.through === 'string' &&
+        typeof options.source === 'string'
+      ) {
+        const throughRelation = getThroughRelation(dbModel, options.through);
+        if (!throughRelation) {
+          delayRelation(delayedRelations, dbModel, options.through, data);
+          continue;
+        }
+
+        const sourceRelation = getSourceRelation(
+          throughRelation,
+          options.source,
+        );
+        if (!sourceRelation) {
+          delayRelation(
+            delayedRelations,
+            throughRelation.model,
+            options.source,
+            data,
+          );
+          continue;
+        }
+      }
+
+      applyRelation(qb, data, delayedRelations);
+    }
+  }
+};
+
+const delayRelation = (
+  delayedRelations: DelayedRelations,
+  model: Query,
+  relationName: string,
+  data: ApplyRelationData,
+) => {
+  let modelRelations = delayedRelations.get(model);
+  if (!modelRelations) {
+    modelRelations = {};
+    delayedRelations.set(model, modelRelations);
+  }
+  if (modelRelations[relationName]) {
+    modelRelations[relationName].push(data);
+  } else {
+    modelRelations[relationName] = [data];
+  }
+};
+
+const applyRelation = (
+  qb: Query,
+  { relationName, relation, dbModel, otherDbModel }: ApplyRelationData,
+  delayedRelations: DelayedRelations,
+) => {
+  const query = (
+    relation.options.scope
+      ? relation.options.scope(otherDbModel)
+      : (otherDbModel 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`,
+    );
+  }
+
+  const { type } = relation;
+  let data;
+  if (type === 'belongsTo') {
+    data = makeBelongsToMethod(relation, 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);
+  } else {
+    throw new Error(`Unknown relation type ${type}`);
+  }
+
+  if (data.returns === 'one') {
+    query._take();
+  }
+
+  makeRelationQuery(dbModel, definedAs, relationName, data);
+
+  (dbModel.relations as Record<string, unknown>)[relationName] = {
+    type,
+    key: relationName,
+    model: otherDbModel,
+    query,
+    nestedInsert: data.nestedInsert,
+    nestedUpdate: data.nestedUpdate,
+    joinQuery: data.joinQuery,
+    primaryKey: data.primaryKey,
+    options: relation.options,
+  };
+
+  const modelRelations = delayedRelations.get(dbModel);
+  if (!modelRelations) return;
+
+  modelRelations[relationName]?.forEach((data) => {
+    applyRelation(qb, data, delayedRelations);
+  });
+};
+
+const makeRelationQuery = (
+  model: Query,
+  definedAs: string,
+  relationName: string,
+  data: RelationData,
+) => {
+  Object.defineProperty(model, relationName, {
+    get() {
+      const toModel = this.db[definedAs].as(relationName) as Query;
+
+      if (data.returns === 'one') {
+        toModel._take();
+      }
+
+      const query = this.isSubQuery
+        ? toModel
+        : toModel._whereExists(data.reverseJoin(this, toModel), (q) => q);
+
+      query.query[relationQueryKey] = {
+        relationName,
+        sourceQuery: this,
+        relationQuery: toModel,
+        joinQuery: data.joinQuery,
+      };
+
+      const setQuery = data.modifyRelatedQuery?.(query);
+      setQuery?.(this);
+
+      return new Proxy(data.method, {
+        get(_, prop) {
+          return (query as unknown as Record<string, unknown>)[prop as string];
+        },
+      }) as unknown as RelationQuery;
+    },
+  });
+};

package/src/relations/utils.ts

@@ -0,0 +1,12 @@
+import { Query, Relation } from 'pqb';
+
+export const getThroughRelation = (model: Query, through: string) => {
+  return (model.relations as Record<string, Relation>)[through];
+};
+
+export const getSourceRelation = (
+  throughRelation: Relation,
+  source: string,
+) => {
+  return (throughRelation.model.relations as Record<string, Relation>)[source];
+};