orchid-orm 1.5.29 → 1.5.31

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

@@ -1,194 +0,0 @@
-import { createBaseTable } from '../table';
-import { tableToZod } from 'orchid-orm-schema-to-zod';
-
-export const BaseTable = createBaseTable({
-  columnTypes: (t) => ({
-    ...t,
-    text: (min = 0, max = Infinity) => t.text(min, max),
-    timestamp() {
-      return t.timestamp().parse((input) => new Date(input));
-    },
-  }),
-});
-
-export type User = UserTable['columns']['type'];
-export class UserTable extends BaseTable {
-  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(() => ProfileTable, {
-      required: true,
-      primaryKey: 'id',
-      foreignKey: 'userId',
-    }),
-
-    messages: this.hasMany(() => MessageTable, {
-      primaryKey: 'id',
-      foreignKey: 'authorId',
-    }),
-
-    chats: this.hasAndBelongsToMany(() => ChatTable, {
-      primaryKey: 'id',
-      foreignKey: 'userId',
-      associationPrimaryKey: 'id',
-      associationForeignKey: 'chatId',
-      joinTable: 'chatUser',
-    }),
-  };
-}
-export const UserSchema = tableToZod(UserTable);
-
-export type Profile = ProfileTable['columns']['type'];
-export class ProfileTable extends BaseTable {
-  table = 'profile';
-  columns = this.setColumns((t) => ({
-    id: t.serial().primaryKey(),
-    userId: t
-      .integer()
-      .nullable()
-      .foreignKey(() => UserTable, 'id'),
-    bio: t.text().nullable(),
-    ...t.timestamps(),
-  }));
-
-  relations = {
-    user: this.belongsTo(() => UserTable, {
-      required: true,
-      primaryKey: 'id',
-      foreignKey: 'userId',
-    }),
-
-    chats: this.hasMany(() => ChatTable, {
-      through: 'user',
-      source: 'chats',
-    }),
-  };
-}
-export const ProfileSchema = tableToZod(ProfileTable);
-
-export type Chat = ChatTable['columns']['type'];
-export class ChatTable extends BaseTable {
-  table = 'chat';
-  columns = this.setColumns((t) => ({
-    id: t.serial().primaryKey(),
-    title: t.text(),
-    ...t.timestamps(),
-  }));
-
-  relations = {
-    users: this.hasAndBelongsToMany(() => UserTable, {
-      primaryKey: 'id',
-      foreignKey: 'chatId',
-      associationPrimaryKey: 'id',
-      associationForeignKey: 'userId',
-      joinTable: 'chatUser',
-    }),
-
-    profiles: this.hasMany(() => ProfileTable, {
-      through: 'users',
-      source: 'profile',
-    }),
-
-    messages: this.hasMany(() => MessageTable, {
-      primaryKey: 'id',
-      foreignKey: 'chatId',
-    }),
-  };
-}
-export const ChatSchema = tableToZod(ChatTable);
-
-export type Message = MessageTable['columns']['type'];
-export class MessageTable extends BaseTable {
-  table = 'message';
-  columns = this.setColumns((t) => ({
-    id: t.serial().primaryKey(),
-    chatId: t.integer().foreignKey(() => ChatTable, 'id'),
-    authorId: t
-      .integer()
-      .nullable()
-      .foreignKey(() => UserTable, 'id'),
-    text: t.text(),
-    ...t.timestamps(),
-  }));
-
-  relations = {
-    user: this.belongsTo(() => UserTable, {
-      primaryKey: 'id',
-      foreignKey: 'authorId',
-    }),
-
-    chat: this.belongsTo(() => ChatTable, {
-      primaryKey: 'id',
-      foreignKey: 'chatId',
-    }),
-
-    profile: this.hasOne(() => ProfileTable, {
-      required: true,
-      through: 'user',
-      source: 'profile',
-    }),
-  };
-}
-export const MessageSchema = tableToZod(MessageTable);
-
-export type Post = PostTable['columns']['type'];
-export class PostTable extends BaseTable {
-  table = 'post';
-  columns = this.setColumns((t) => ({
-    id: t.serial().primaryKey(),
-    userId: t.integer().foreignKey(() => UserTable, 'id'),
-    title: t.text(),
-    ...t.timestamps(),
-  }));
-
-  relations = {
-    postTags: this.hasMany(() => PostTagTable, {
-      primaryKey: 'id',
-      foreignKey: 'postId',
-    }),
-  };
-}
-export const PostSchema = tableToZod(PostTable);
-
-export type PostTag = PostTagTable['columns']['type'];
-export class PostTagTable extends BaseTable {
-  table = 'postTag';
-  columns = this.setColumns((t) => ({
-    postId: t.integer().foreignKey(() => PostTable, 'id'),
-    tag: t.text().foreignKey(() => TagTable, 'tag'),
-    ...t.primaryKey(['postId', 'tag']),
-  }));
-
-  relations = {
-    tag: this.belongsTo(() => TagTable, {
-      primaryKey: 'tag',
-      foreignKey: 'tag',
-    }),
-  };
-}
-export const PostTagSchema = tableToZod(PostTagTable);
-
-export type Tag = TagTable['columns']['type'];
-export class TagTable extends BaseTable {
-  table = 'tag';
-  columns = this.setColumns((t) => ({
-    tag: t.text().primaryKey(),
-  }));
-}

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

@@ -1,119 +0,0 @@
-import {
-  patchPgForTransactions,
-  rollbackTransaction,
-  startTransaction,
-} from 'pg-transactional-tests';
-import { db } from './test-db';
-import { DeleteQueryData, InsertQueryData, Query, UpdateQueryData } from 'pqb';
-
-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();
-  });
-};
-
-export const useRelationCallback = (rel: { query: Query }) => {
-  const beforeCreate = jest.fn();
-  const afterCreate = jest.fn();
-  const beforeUpdate = jest.fn();
-  const afterUpdate = jest.fn();
-  const beforeDelete = jest.fn();
-  const afterDelete = jest.fn();
-  const relQuery = rel.query;
-
-  beforeAll(() => {
-    relQuery._beforeCreate(beforeCreate);
-    relQuery._afterCreate(afterCreate);
-    relQuery._beforeUpdate(beforeUpdate);
-    relQuery._afterUpdate(afterUpdate);
-    relQuery._beforeDelete(beforeDelete);
-    relQuery._afterDelete(afterDelete);
-  });
-
-  afterAll(() => {
-    let q;
-    q = relQuery.query as InsertQueryData;
-    q.beforeCreate?.pop();
-    q.afterCreate?.pop();
-    q = relQuery.query as UpdateQueryData;
-    q.beforeUpdate?.pop();
-    q.afterUpdate?.pop();
-    q = relQuery.query as DeleteQueryData;
-    q.beforeDelete?.pop();
-    q.afterDelete?.pop();
-  });
-
-  return {
-    beforeCreate,
-    afterCreate,
-    beforeUpdate,
-    afterUpdate,
-    beforeDelete,
-    afterDelete,
-    resetMocks() {
-      beforeCreate.mockReset();
-      afterCreate.mockReset();
-      beforeUpdate.mockReset();
-      afterUpdate.mockReset();
-      beforeDelete.mockReset();
-      afterDelete.mockReset();
-    },
-  };
-};

package/src/transaction.test.ts

@@ -1,47 +0,0 @@
-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', () => {
-  afterAll(db.$close);
-
-  it('should have override transaction method which implicitly connects tables 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

@@ -1,27 +0,0 @@
-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 table = value.transacting(q);
-        table.__table = table;
-        (table as unknown as { db: unknown }).db = orm;
-        orm[key] = table;
-      } else {
-        orm[key] = value;
-      }
-    }
-
-    return fn(orm);
-  });
-}

package/src/utils.ts

@@ -1,9 +0,0 @@
-export const toPascalCase = (s: string) => {
-  const words = s.match(/(\w)(\w*)/g) || [];
-  return words.map((word) => word[0].toUpperCase() + word.slice(1)).join('');
-};
-
-export const toCamelCase = (s: string) => {
-  const pascal = toPascalCase(s);
-  return pascal[0].toLowerCase() + pascal.slice(1);
-};

package/tsconfig.json

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