orchid-orm 1.5.28 → 1.5.30

package/src/repo.test.ts

@@ -1,200 +0,0 @@
-import { orchidORM } from './orm';
-import { pgConfig } from './test-utils/test-db';
-import { createBaseTable } from './table';
-import { assertType, expectSql } from './test-utils/test-utils';
-import { QueryReturnType } from 'pqb';
-import { createRepo } from './repo';
-
-const BaseTable = createBaseTable();
-
-class SomeTable extends BaseTable {
-  table = 'someTable';
-  columns = this.setColumns((t) => ({
-    id: t.serial().primaryKey(),
-    name: t.text(0, 100),
-  }));
-
-  relations = {
-    other: this.hasMany(() => OtherTable, {
-      primaryKey: 'id',
-      foreignKey: 'someId',
-    }),
-  };
-}
-
-class OtherTable extends BaseTable {
-  table = 'otherTable';
-  columns = this.setColumns((t) => ({
-    id: t.serial().primaryKey(),
-    someId: t.integer().foreignKey(() => SomeTable, 'id'),
-    anotherId: t.integer().foreignKey(() => AnotherTable, 'id'),
-  }));
-
-  relations = {
-    some: this.belongsTo(() => SomeTable, {
-      primaryKey: 'id',
-      foreignKey: 'someId',
-    }),
-    another: this.belongsTo(() => AnotherTable, {
-      primaryKey: 'id',
-      foreignKey: 'anotherId',
-    }),
-  };
-}
-
-class AnotherTable extends BaseTable {
-  table = 'another';
-  columns = this.setColumns((t) => ({
-    id: t.serial().primaryKey(),
-  }));
-}
-
-const db = orchidORM(pgConfig, {
-  some: SomeTable,
-  other: OtherTable,
-  another: AnotherTable,
-});
-
-describe('createRepo', () => {
-  describe('queryMethods', () => {
-    const repo = createRepo(db.some, {
-      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 table 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.other.select('id', {
-        some: (q) => repo(q.some).one().two().three(123),
-      });
-
-      assertType<
-        Awaited<typeof q>,
-        { id: number; some: { id: number; name: string } | null }[]
-      >();
-
-      expectSql(
-        q.toSql(),
-        `
-          SELECT
-            "otherTable"."id",
-            (
-              SELECT row_to_json("t".*)
-              FROM (
-                SELECT "some"."id", "some"."name"
-                FROM "someTable" AS "some"
-                WHERE "some"."id" = $1
-                  AND "some"."id" = "otherTable"."someId"
-                LIMIT $2
-              ) AS "t"
-            ) AS "some"
-          FROM "otherTable"
-        `,
-        [123, 1],
-      );
-    });
-  });
-
-  describe('queryOneMethods', () => {
-    const repo = createRepo(db.some, {
-      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.some, {
-      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.some, {
-      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.some, {
-      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

@@ -1,119 +0,0 @@
-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>>(
-  table: 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.__table);
-    proto.__table = proto;
-    const result = Object.create(proto);
-    result.query = getClonedQueryData(q.query);
-
-    if (plainMethods) {
-      Object.assign(proto.__table, plainMethods);
-    }
-
-    for (const key in queryMethods) {
-      const method = queryMethods[key] as (...args: unknown[]) => unknown;
-      (proto.__table as unknown as Record<string, unknown>)[key] = function (
-        ...args: unknown[]
-      ) {
-        return method(this, ...args);
-      };
-    }
-
-    return result;
-  };
-
-  const q = repo(table);
-
-  return new Proxy(repo, {
-    get(_, key) {
-      return q[key];
-    },
-  }) as unknown as Repo<T, Methods>;
-};

package/src/table.test.ts

@@ -1,121 +0,0 @@
-import { createBaseTable } from './table';
-import { orchidORM } from './orm';
-import { adapter, db } from './test-utils/test-db';
-import { assertType, userData, useTestDatabase } from './test-utils/test-utils';
-import { ColumnType, Operators } from 'pqb';
-import { BaseTable } from './test-utils/test-tables';
-
-describe('table', () => {
-  useTestDatabase();
-
-  describe('overriding column types', () => {
-    it('should have .raw with overridden types', () => {
-      class Type extends ColumnType {
-        dataType = 'type';
-        operators = Operators.any;
-        toCode() {
-          return '';
-        }
-      }
-      const type = new Type();
-      const BaseTable = createBaseTable({ columnTypes: { type: () => type } });
-      class UserTable extends BaseTable {
-        table = 'user';
-        columns = this.setColumns((t) => ({
-          id: t.type().primaryKey(),
-          createdAt: t.type(),
-        }));
-      }
-
-      const { user } = orchidORM(
-        { adapter },
-        {
-          user: UserTable,
-        },
-      );
-
-      const value = user.raw((t) => t.type(), '');
-
-      expect(value.__column).toBe(type);
-    });
-
-    it('should return date as string by default', async () => {
-      await db.user.create(userData);
-
-      const BaseTable = createBaseTable();
-      class UserTable extends BaseTable {
-        table = 'user';
-        columns = this.setColumns((t) => ({
-          id: t.serial().primaryKey(),
-          createdAt: t.timestamp(),
-        }));
-      }
-
-      const { user } = orchidORM(
-        { adapter },
-        {
-          user: UserTable,
-        },
-      );
-
-      const result = await user.get('createdAt');
-      expect(typeof result).toBe('string');
-
-      assertType<typeof result, string>();
-    });
-
-    it('should return date as Date when overridden', async () => {
-      await db.user.create(userData);
-
-      const BaseTable = createBaseTable({
-        columnTypes: (t) => ({
-          serial: t.serial,
-          timestamp() {
-            return t.timestamp().parse((input) => new Date(input));
-          },
-        }),
-      });
-
-      class UserTable extends BaseTable {
-        table = 'user';
-        columns = this.setColumns((t) => ({
-          id: t.serial().primaryKey(),
-          createdAt: t.timestamp(),
-        }));
-      }
-
-      const { user } = orchidORM(
-        { adapter },
-        {
-          user: UserTable,
-        },
-      );
-
-      const result = await user.get('createdAt');
-      expect(result instanceof Date).toBe(true);
-
-      assertType<typeof result, Date>();
-    });
-  });
-
-  describe('noPrimaryKey', () => {
-    it('should allow to the table to not have a primary key', () => {
-      class UserTable extends BaseTable {
-        table = 'user';
-        noPrimaryKey = true;
-        columns = this.setColumns((t) => ({
-          name: t.text(),
-        }));
-      }
-
-      orchidORM(
-        {
-          adapter,
-        },
-        {
-          user: UserTable,
-        },
-      );
-    });
-  });
-});

package/src/table.ts

@@ -1,184 +0,0 @@
-import {
-  ColumnShapeOutput,
-  ColumnsShape,
-  columnTypes,
-  ColumnTypesBase,
-  Db,
-  DefaultColumnTypes,
-  getColumnTypes,
-  Query,
-} from 'pqb';
-import { MapRelations, Relation, RelationThunks } from './relations/relations';
-import { OrchidORM } from './orm';
-
-export type TableClass<T extends Table = Table> = new () => T;
-
-export type TableClasses = Record<string, TableClass>;
-
-export type TableToDb<T extends Table> = Db<
-  T['table'],
-  T['columns']['shape'],
-  'relations' extends keyof T
-    ? T['relations'] extends RelationThunks
-      ? {
-          [K in keyof T['relations']]: Relation<T, T['relations'], K>;
-        }
-      : Query['relations']
-    : Query['relations'],
-  T['columnTypes']
-> & { definedAs: string; db: OrchidORM<TableClasses> };
-
-export type DbTable<T extends TableClass> = TableToDb<InstanceType<T>> &
-  Omit<MapRelations<InstanceType<T>>, keyof Query>;
-
-type TableConfig = {
-  shape: ColumnsShape;
-  type: unknown;
-};
-
-type ScopeFn<Related extends TableClass, Scope extends Query> = (
-  q: DbTable<Related>,
-) => Scope;
-
-export type Table = {
-  table: string;
-  columns: TableConfig;
-  schema?: string;
-  columnTypes: ColumnTypesBase;
-  noPrimaryKey?: boolean;
-};
-
-export const createBaseTable = <CT extends ColumnTypesBase>(
-  options: {
-    columnTypes?: CT | ((t: DefaultColumnTypes) => CT);
-  } = { columnTypes: columnTypes as unknown as CT },
-) => {
-  const ct =
-    typeof options.columnTypes === 'function'
-      ? options.columnTypes(columnTypes)
-      : options.columnTypes;
-
-  return create(ct as ColumnTypesBase extends CT ? DefaultColumnTypes : CT);
-};
-
-const create = <CT extends ColumnTypesBase>(columnTypes: CT) => {
-  return class BaseTable {
-    table!: string;
-    columns!: TableConfig;
-    schema?: string;
-    columnTypes: CT;
-    noPrimaryKey?: boolean;
-
-    constructor() {
-      this.columnTypes = columnTypes;
-    }
-
-    setColumns = <T extends ColumnsShape>(
-      fn: (t: CT) => T,
-    ): { shape: T; type: ColumnShapeOutput<T> } => {
-      const shape = getColumnTypes(columnTypes, fn);
-
-      return {
-        shape,
-        type: undefined as unknown as ColumnShapeOutput<T>,
-      };
-    };
-
-    belongsTo<
-      Self extends this,
-      Related extends TableClass,
-      Scope extends Query,
-      Options extends {
-        primaryKey: keyof InstanceType<Related>['columns']['shape'];
-        foreignKey: keyof Self['columns']['shape'];
-        scope?: ScopeFn<Related, Scope>;
-        required?: boolean;
-      },
-    >(this: Self, fn: () => Related, options: Options) {
-      return {
-        type: 'belongsTo' as const,
-        returns: 'one' as const,
-        fn,
-        options,
-      };
-    }
-
-    hasOne<
-      Self extends this,
-      Related extends TableClass,
-      Scope extends Query,
-      Through extends string,
-      Source extends string,
-      Options extends (
-        | {
-            primaryKey: keyof Self['columns']['shape'];
-            foreignKey: keyof InstanceType<Related>['columns']['shape'];
-          }
-        | {
-            through: Through;
-            source: Source;
-          }
-      ) & {
-        scope?: ScopeFn<Related, Scope>;
-        required?: boolean;
-      },
-    >(this: Self, fn: () => Related, options: Options) {
-      return {
-        type: 'hasOne' as const,
-        returns: 'one' as const,
-        fn,
-        options,
-      };
-    }
-
-    hasMany<
-      Self extends this,
-      Related extends TableClass,
-      Scope extends Query,
-      Through extends string,
-      Source extends string,
-      Options extends (
-        | {
-            primaryKey: keyof Self['columns']['shape'];
-            foreignKey: keyof InstanceType<Related>['columns']['shape'];
-          }
-        | {
-            through: Through;
-            source: Source;
-          }
-      ) & {
-        scope?: ScopeFn<Related, Scope>;
-        required?: boolean;
-      },
-    >(this: Self, fn: () => Related, options: Options) {
-      return {
-        type: 'hasMany' as const,
-        returns: 'many' as const,
-        fn,
-        options,
-      };
-    }
-
-    hasAndBelongsToMany<
-      Self extends this,
-      Related extends TableClass,
-      Scope extends Query,
-      Options extends {
-        primaryKey: keyof Self['columns']['shape'];
-        associationPrimaryKey: keyof InstanceType<Related>['columns']['shape'];
-        foreignKey: string;
-        associationForeignKey: string;
-        joinTable: string;
-        scope?: ScopeFn<Related, Scope>;
-        required?: boolean;
-      },
-    >(this: Self, fn: () => Related, options: Options) {
-      return {
-        type: 'hasAndBelongsToMany' as const,
-        returns: 'many' as const,
-        fn,
-        options,
-      };
-    }
-  };
-};

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

@@ -1,32 +0,0 @@
-import { orchidORM } from '../orm';
-import {
-  ChatTable,
-  MessageTable,
-  PostTable,
-  PostTagTable,
-  ProfileTable,
-  TagTable,
-  UserTable,
-} from './test-tables';
-
-export const pgConfig = {
-  databaseURL: process.env.DATABASE_URL,
-};
-
-export const db = orchidORM(
-  {
-    ...pgConfig,
-    log: false,
-  },
-  {
-    user: UserTable,
-    profile: ProfileTable,
-    chat: ChatTable,
-    message: MessageTable,
-    post: PostTable,
-    postTag: PostTagTable,
-    tag: TagTable,
-  },
-);
-
-export const adapter = db.$adapter;