orchid-orm 0.0.1

package/src/repo.test.ts

@@ -0,0 +1,200 @@
+import { orchidORM } from './orm';
+import { pgConfig } from './test-utils/test-db';
+import { createModel } from './model';
+import { assertType, expectSql } from './test-utils/test-utils';
+import { columnTypes, QueryReturnType } from 'pqb';
+import { createRepo } from './repo';
+
+const Model = createModel({ columnTypes });
+
+class SomeModel extends Model {
+  table = 'someTable';
+  columns = this.setColumns((t) => ({
+    id: t.serial().primaryKey(),
+    name: t.text(),
+  }));
+
+  relations = {
+    otherModel: this.hasMany(() => OtherModel, {
+      primaryKey: 'id',
+      foreignKey: 'someId',
+    }),
+  };
+}
+
+class OtherModel extends Model {
+  table = 'otherTable';
+  columns = this.setColumns((t) => ({
+    id: t.serial().primaryKey(),
+    someId: t.integer().foreignKey(() => SomeModel, 'id'),
+    anotherId: t.integer().foreignKey(() => AnotherModel, 'id'),
+  }));
+
+  relations = {
+    someModel: this.belongsTo(() => SomeModel, {
+      primaryKey: 'id',
+      foreignKey: 'someId',
+    }),
+    anotherModel: this.belongsTo(() => AnotherModel, {
+      primaryKey: 'id',
+      foreignKey: 'anotherId',
+    }),
+  };
+}
+
+class AnotherModel extends Model {
+  table = 'anotherModel';
+  columns = this.setColumns((t) => ({
+    id: t.serial().primaryKey(),
+  }));
+}
+
+const db = orchidORM(pgConfig, {
+  someModel: SomeModel,
+  otherModel: OtherModel,
+  anotherModel: AnotherModel,
+});
+
+describe('createRepo', () => {
+  describe('queryMethods', () => {
+    const repo = createRepo(db.someModel, {
+      queryMethods: {
+        one(q) {
+          return q.select('id');
+        },
+        two(q) {
+          return q.select('name');
+        },
+        three(q, id: number) {
+          return q.where({ id });
+        },
+      },
+    });
+
+    it('should accept user defined methods and allow to use them on the model with chaining', async () => {
+      const q = repo.one().two().three(123).take();
+
+      assertType<Awaited<typeof q>, { id: number; name: string }>();
+
+      expectSql(
+        q.toSql(),
+        `
+          SELECT "someTable"."id", "someTable"."name"
+          FROM "someTable"
+          WHERE "someTable"."id" = $1
+          LIMIT $2
+        `,
+        [123, 1],
+      );
+    });
+
+    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),
+      });
+
+      assertType<
+        Awaited<typeof q>,
+        { id: number; someModel: { id: number; name: string } | null }[]
+      >();
+
+      expectSql(
+        q.toSql(),
+        `
+          SELECT
+            "otherTable"."id",
+            (
+              SELECT row_to_json("t".*)
+              FROM (
+                SELECT "someModel"."id", "someModel"."name"
+                FROM "someTable" AS "someModel"
+                WHERE "someModel"."id" = $1
+                  AND "someModel"."id" = "otherTable"."someId"
+                LIMIT $2
+              ) AS "t"
+            ) AS "someModel"
+          FROM "otherTable"
+        `,
+        [123, 1],
+      );
+    });
+  });
+
+  describe('queryOneMethods', () => {
+    const repo = createRepo(db.someModel, {
+      queryOneMethods: {
+        one(q) {
+          const type: Exclude<QueryReturnType, 'all'> = q.returnType;
+          return type;
+        },
+      },
+    });
+
+    it('should define methods which are available only after .take, .find, or similar', () => {
+      // @ts-expect-error should prevent using method on query which returns multiple
+      repo.one();
+
+      repo.take().one();
+      repo.find(1).one();
+    });
+  });
+
+  describe('queryWithWhereMethods', () => {
+    const repo = createRepo(db.someModel, {
+      queryWithWhereMethods: {
+        one(q) {
+          const hasWhere: true = q.hasWhere;
+          return hasWhere;
+        },
+      },
+    });
+
+    it('should define methods which are available only after .where, .find, or similar', () => {
+      // @ts-expect-error should prevent using method on query without where conditions
+      repo.one();
+      // @ts-expect-error should prevent using method on query without where conditions
+      repo.take().one();
+
+      repo.where().one();
+      repo.find(1).one();
+    });
+  });
+
+  describe('queryOneWithWhere', () => {
+    const repo = createRepo(db.someModel, {
+      queryOneWithWhereMethods: {
+        one(q) {
+          const type: Exclude<QueryReturnType, 'all'> = q.returnType;
+          const hasWhere: true = q.hasWhere;
+          return [type, hasWhere];
+        },
+      },
+    });
+
+    it('should define methods which are available only after .where, .find, or similar', () => {
+      // @ts-expect-error should prevent using method on query without where conditions
+      repo.one();
+      // @ts-expect-error should prevent using method on query without where conditions
+      repo.take().one();
+
+      // @ts-expect-error should prevent using method on query which returns multiple
+      repo.where().one();
+
+      repo.find(1).one();
+    });
+  });
+
+  describe('methods', () => {
+    const repo = createRepo(db.someModel, {
+      methods: {
+        one(a: number, b: string) {
+          return a + b;
+        },
+      },
+    });
+
+    it('should assign methods as is to the repo', () => {
+      expect(repo.take().one(1, '2')).toBe('12');
+    });
+  });
+});

package/src/repo.ts

@@ -0,0 +1,119 @@
+import {
+  EmptyObject,
+  getClonedQueryData,
+  MergeQuery,
+  Query,
+  QueryReturnType,
+  SetQueryReturns,
+  WhereResult,
+} from 'pqb';
+
+export type QueryMethods<T extends Query> = Record<
+  string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (q: T, ...args: any[]) => any
+>;
+
+type QueryOne<T extends Query> = SetQueryReturns<
+  T,
+  Exclude<QueryReturnType, 'all'>
+>;
+
+export type MethodsBase<T extends Query> = {
+  queryMethods?: QueryMethods<T>;
+  queryOneMethods?: QueryMethods<QueryOne<T>>;
+  queryWithWhereMethods?: QueryMethods<WhereResult<T>>;
+  queryOneWithWhereMethods?: QueryMethods<QueryOne<WhereResult<T>>>;
+  methods?: Record<string, unknown>;
+};
+
+export type MapQueryMethods<
+  T extends Query,
+  BaseQuery extends Query,
+  Methods,
+> = Methods extends QueryMethods<T>
+  ? {
+      [K in keyof Methods]: Methods[K] extends (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        q: any,
+        ...args: infer Args
+      ) => // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      infer Result
+        ? <T extends BaseQuery>(
+            this: T,
+            ...args: Args
+          ) => Result extends Query ? MergeQuery<T, Result> : Result
+        : never;
+    }
+  : EmptyObject;
+
+export type MapMethods<
+  T extends Query,
+  Methods extends MethodsBase<T>,
+> = MapQueryMethods<T, Query, Methods['queryMethods']> &
+  MapQueryMethods<QueryOne<T>, QueryOne<Query>, Methods['queryOneMethods']> &
+  MapQueryMethods<
+    WhereResult<T>,
+    WhereResult<Query>,
+    Methods['queryWithWhereMethods']
+  > &
+  MapQueryMethods<
+    QueryOne<WhereResult<T>>,
+    QueryOne<WhereResult<Query>>,
+    Methods['queryOneWithWhereMethods']
+  > &
+  (Methods['methods'] extends Record<string, unknown>
+    ? Methods['methods']
+    : EmptyObject);
+
+export type Repo<
+  T extends Query,
+  Methods extends MethodsBase<T>,
+  Mapped = MapMethods<T, Methods>,
+> = (<Q extends { table: T['table']; shape: T['shape'] }>(q: Q) => Q & Mapped) &
+  T &
+  Mapped;
+
+export const createRepo = <T extends Query, Methods extends MethodsBase<T>>(
+  model: T,
+  methods: Methods,
+): Repo<T, Methods> => {
+  const queryMethods = {
+    ...methods.queryMethods,
+    ...methods.queryOneMethods,
+    ...methods.queryWithWhereMethods,
+    ...methods.queryOneWithWhereMethods,
+  };
+
+  const plainMethods = methods.methods;
+
+  const repo = (q: Query) => {
+    const proto = Object.create(q.__model);
+    proto.__model = proto;
+    const result = Object.create(proto);
+    result.query = getClonedQueryData(q.query);
+
+    if (plainMethods) {
+      Object.assign(proto.__model, plainMethods);
+    }
+
+    for (const key in queryMethods) {
+      const method = queryMethods[key] as (...args: unknown[]) => unknown;
+      (proto.__model as unknown as Record<string, unknown>)[key] = function (
+        ...args: unknown[]
+      ) {
+        return method(this, ...args);
+      };
+    }
+
+    return result;
+  };
+
+  const q = repo(model);
+
+  return new Proxy(repo, {
+    get(_, key) {
+      return q[key];
+    },
+  }) as unknown as Repo<T, Methods>;
+};

package/src/test-utils/test-db.ts

@@ -0,0 +1,32 @@
+import { orchidORM } from '../orm';
+import {
+  ChatModel,
+  MessageModel,
+  PostModel,
+  PostTagModel,
+  ProfileModel,
+  TagModel,
+  UserModel,
+} from './test-models';
+
+export const pgConfig = {
+  connectionString: process.env.DATABASE_URL,
+};
+
+export const db = orchidORM(
+  {
+    ...pgConfig,
+    log: false,
+  },
+  {
+    user: UserModel,
+    profile: ProfileModel,
+    chat: ChatModel,
+    message: MessageModel,
+    post: PostModel,
+    postTag: PostTagModel,
+    tag: TagModel,
+  },
+);
+
+export const adapter = db.$adapter;

package/src/test-utils/test-models.ts

@@ -0,0 +1,194 @@
+import { createModel } from '../model';
+import { columnTypes } from 'pqb';
+import { modelToZod } from 'orchid-orm-schema-to-zod';
+
+export const Model = createModel({
+  columnTypes: {
+    ...columnTypes,
+    timestamp() {
+      return columnTypes.timestamp().parse((input) => new Date(input));
+    },
+  },
+});
+
+export type User = UserModel['columns']['type'];
+export class UserModel extends Model {
+  table = 'user';
+  columns = this.setColumns((t) => ({
+    id: t.serial().primaryKey(),
+    name: t.text(),
+    password: t.text(),
+    picture: t.text().nullable(),
+    data: t
+      .json((j) =>
+        j.object({
+          name: j.string(),
+          tags: j.string().array(),
+        }),
+      )
+      .nullable(),
+    age: t.integer().nullable(),
+    active: t.boolean().nullable(),
+    ...t.timestamps(),
+  }));
+
+  relations = {
+    profile: this.hasOne(() => ProfileModel, {
+      required: true,
+      primaryKey: 'id',
+      foreignKey: 'userId',
+    }),
+
+    messages: this.hasMany(() => MessageModel, {
+      primaryKey: 'id',
+      foreignKey: 'authorId',
+    }),
+
+    chats: this.hasAndBelongsToMany(() => ChatModel, {
+      primaryKey: 'id',
+      foreignKey: 'userId',
+      associationPrimaryKey: 'id',
+      associationForeignKey: 'chatId',
+      joinTable: 'chatUser',
+    }),
+  };
+}
+export const UserSchema = modelToZod(UserModel);
+
+export type Profile = ProfileModel['columns']['type'];
+export class ProfileModel extends Model {
+  table = 'profile';
+  columns = this.setColumns((t) => ({
+    id: t.serial().primaryKey(),
+    userId: t
+      .integer()
+      .nullable()
+      .foreignKey(() => UserModel, 'id'),
+    bio: t.text().nullable(),
+    ...t.timestamps(),
+  }));
+
+  relations = {
+    user: this.belongsTo(() => UserModel, {
+      required: true,
+      primaryKey: 'id',
+      foreignKey: 'userId',
+    }),
+
+    chats: this.hasMany(() => ChatModel, {
+      through: 'user',
+      source: 'chats',
+    }),
+  };
+}
+export const ProfileSchema = modelToZod(ProfileModel);
+
+export type Chat = ChatModel['columns']['type'];
+export class ChatModel extends Model {
+  table = 'chat';
+  columns = this.setColumns((t) => ({
+    id: t.serial().primaryKey(),
+    title: t.text(),
+    ...t.timestamps(),
+  }));
+
+  relations = {
+    users: this.hasAndBelongsToMany(() => UserModel, {
+      primaryKey: 'id',
+      foreignKey: 'chatId',
+      associationPrimaryKey: 'id',
+      associationForeignKey: 'userId',
+      joinTable: 'chatUser',
+    }),
+
+    profiles: this.hasMany(() => ProfileModel, {
+      through: 'users',
+      source: 'profile',
+    }),
+
+    messages: this.hasMany(() => MessageModel, {
+      primaryKey: 'id',
+      foreignKey: 'chatId',
+    }),
+  };
+}
+export const ChatSchema = modelToZod(ChatModel);
+
+export type Message = MessageModel['columns']['type'];
+export class MessageModel extends Model {
+  table = 'message';
+  columns = this.setColumns((t) => ({
+    id: t.serial().primaryKey(),
+    chatId: t.integer().foreignKey(() => ChatModel, 'id'),
+    authorId: t
+      .integer()
+      .nullable()
+      .foreignKey(() => UserModel, 'id'),
+    text: t.text(),
+    ...t.timestamps(),
+  }));
+
+  relations = {
+    user: this.belongsTo(() => UserModel, {
+      primaryKey: 'id',
+      foreignKey: 'authorId',
+    }),
+
+    chat: this.belongsTo(() => ChatModel, {
+      primaryKey: 'id',
+      foreignKey: 'chatId',
+    }),
+
+    profile: this.hasOne(() => ProfileModel, {
+      required: true,
+      through: 'user',
+      source: 'profile',
+    }),
+  };
+}
+export const MessageSchema = modelToZod(MessageModel);
+
+export type Post = PostModel['columns']['type'];
+export class PostModel extends Model {
+  table = 'post';
+  columns = this.setColumns((t) => ({
+    id: t.serial().primaryKey(),
+    userId: t.integer().foreignKey(() => UserModel, 'id'),
+    title: t.text(),
+    ...t.timestamps(),
+  }));
+
+  relations = {
+    postTags: this.hasMany(() => PostTagModel, {
+      primaryKey: 'id',
+      foreignKey: 'postId',
+    }),
+  };
+}
+export const PostSchema = modelToZod(PostModel);
+
+export type PostTag = PostTagModel['columns']['type'];
+export class PostTagModel extends Model {
+  table = 'postTag';
+  columns = this.setColumns((t) => ({
+    postId: t.integer().foreignKey(() => PostModel, 'id'),
+    tag: t.text().foreignKey(() => TagModel, 'tag'),
+    ...t.primaryKey(['postId', 'tag']),
+  }));
+
+  relations = {
+    tag: this.belongsTo(() => TagModel, {
+      primaryKey: 'tag',
+      foreignKey: 'tag',
+    }),
+  };
+}
+export const PostTagSchema = modelToZod(PostTagModel);
+
+export type Tag = TagModel['columns']['type'];
+export class TagModel extends Model {
+  table = 'tag';
+  columns = this.setColumns((t) => ({
+    tag: t.text().primaryKey(),
+  }));
+}

package/src/test-utils/test-utils.ts

@@ -0,0 +1,69 @@
+import {
+  patchPgForTransactions,
+  rollbackTransaction,
+  startTransaction,
+} from 'pg-transactional-tests';
+import { db } from './test-db';
+
+type AssertEqual<T, Expected> = [T] extends [Expected]
+  ? [Expected] extends [T]
+    ? true
+    : false
+  : false;
+
+export const assertType = <T, Expected>(
+  ..._: AssertEqual<T, Expected> extends true ? [] : ['invalid type']
+) => {
+  // noop
+};
+
+export const line = (s: string) =>
+  s.trim().replace(/\s+/g, ' ').replace(/\( /g, '(').replace(/ \)/g, ')');
+
+export const expectSql = (
+  sql: { text: string; values: unknown[] },
+  text: string,
+  values: unknown[] = [],
+) => {
+  expect(sql.text).toBe(line(text));
+  expect(sql.values).toEqual(values);
+};
+
+export const toLine = (s: string) => {
+  return s.trim().replace(/\n\s*/g, ' ');
+};
+
+export const now = new Date();
+export const userData = {
+  name: 'name',
+  password: 'password',
+  updatedAt: now,
+  createdAt: now,
+};
+
+export const profileData = {
+  bio: 'bio',
+  updatedAt: now,
+  createdAt: now,
+};
+
+export const chatData = {
+  title: 'chat',
+  updatedAt: now,
+  createdAt: now,
+};
+
+export const messageData = {
+  text: 'text',
+  updatedAt: now,
+  createdAt: now,
+};
+
+export const useTestDatabase = () => {
+  beforeAll(patchPgForTransactions);
+  beforeEach(startTransaction);
+  afterEach(rollbackTransaction);
+  afterAll(async () => {
+    await db.$close();
+  });
+};

package/src/transaction.test.ts

@@ -0,0 +1,45 @@
+import { db } from './test-utils/test-db';
+import { profileData, toLine, userData } from './test-utils/test-utils';
+import { Client } from 'pg';
+import { noop } from 'pqb';
+
+describe('transaction', () => {
+  it('should have override transaction method which implicitly connects models with a single transaction', async () => {
+    const spy = jest.spyOn(Client.prototype, 'query');
+
+    await db
+      .$transaction(async (db) => {
+        await db.user.create(userData);
+        await db.profile.create(profileData);
+        throw new Error('Throw error to rollback');
+      })
+      .catch(noop);
+
+    expect(
+      spy.mock.calls.map(
+        (call) => (call[0] as unknown as { text: string }).text,
+      ),
+    ).toEqual([
+      'BEGIN',
+      toLine(`
+        INSERT INTO "user"("name", "password", "updatedAt", "createdAt")
+        VALUES ($1, $2, $3, $4)
+        RETURNING *
+      `),
+      toLine(`
+        INSERT INTO "profile"("bio", "updatedAt", "createdAt")
+        VALUES ($1, $2, $3)
+        RETURNING *
+      `),
+      'ROLLBACK',
+    ]);
+  });
+
+  it('should throw error if argument is forgotten', async () => {
+    expect(() =>
+      db.$transaction(async () => {
+        // noop
+      }),
+    ).toThrow('Argument of $transaction callback should be used');
+  });
+});

package/src/transaction.ts

@@ -0,0 +1,27 @@
+import { Db } from 'pqb';
+
+export function transaction<T extends { $queryBuilder: Db }, Result>(
+  this: T,
+  fn: (db: T) => Promise<Result>,
+): Promise<Result> {
+  if (fn.length === 0) {
+    throw new Error('Argument of $transaction callback should be used');
+  }
+
+  return this.$queryBuilder.transaction((q) => {
+    const orm = {} as T;
+    for (const key in this) {
+      const value = this[key];
+      if (value instanceof Db) {
+        const model = value.transacting(q);
+        model.__model = model;
+        (model as unknown as { db: unknown }).db = orm;
+        orm[key] = model;
+      } else {
+        orm[key] = value;
+      }
+    }
+
+    return fn(orm);
+  });
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["./src", "jest-setup.ts"],
+  "compilerOptions": {
+    "outDir": "./dist",
+    "noEmit": false,
+    "baseUrl": ".",
+    "paths": {
+      "pqb": ["../pqb/src"],
+      "orchid-orm-schema-to-zod": ["../schema-to-zod/src"]
+    }
+  }
+}