orchid-orm 1.3.16 → 1.4.16

package/src/{model.ts → table.ts}

@@ -9,11 +9,11 @@ import {
 import { MapRelations, Relation, RelationThunks } from './relations/relations';
 import { OrchidORM } from './orm';
 
-export type ModelClass<T extends Model = Model> = new () => T;
+export type TableClass<T extends Table = Table> = new () => T;
 
-export type ModelClasses = Record<string, ModelClass>;
+export type TableClasses = Record<string, TableClass>;
 
-export type ModelToDb<T extends Model> = Db<
+export type TableToDb<T extends Table> = Db<
   T['table'],
   T['columns']['shape'],
   'relations' extends keyof T
@@ -24,34 +24,34 @@ export type ModelToDb<T extends Model> = Db<
       : Query['relations']
     : Query['relations'],
   T['columnTypes']
-> & { definedAs: string; db: OrchidORM<ModelClasses> };
+> & { definedAs: string; db: OrchidORM<TableClasses> };
 
-export type DbModel<T extends ModelClass> = ModelToDb<InstanceType<T>> &
+export type DbTable<T extends TableClass> = TableToDb<InstanceType<T>> &
   Omit<MapRelations<InstanceType<T>>, keyof Query>;
 
-type ModelConfig = {
+type TableConfig = {
   shape: ColumnsShape;
   type: unknown;
 };
 
-type ScopeFn<Related extends ModelClass, Scope extends Query> = (
-  q: DbModel<Related>,
+type ScopeFn<Related extends TableClass, Scope extends Query> = (
+  q: DbTable<Related>,
 ) => Scope;
 
-export type Model = {
+export type Table = {
   table: string;
-  columns: ModelConfig;
+  columns: TableConfig;
   schema?: string;
   columnTypes: ColumnTypesBase;
   noPrimaryKey?: boolean;
 };
 
-export const createModel = <CT extends ColumnTypesBase>(options: {
+export const createBaseTable = <CT extends ColumnTypesBase>(options: {
   columnTypes: CT;
 }) => {
-  return class Model {
+  return class BaseTable {
     table!: string;
-    columns!: ModelConfig;
+    columns!: TableConfig;
     schema?: string;
     columnTypes: CT;
     noPrimaryKey?: boolean;
@@ -73,7 +73,7 @@ export const createModel = <CT extends ColumnTypesBase>(options: {
 
     belongsTo<
       Self extends this,
-      Related extends ModelClass,
+      Related extends TableClass,
       Scope extends Query,
       Options extends {
         primaryKey: keyof InstanceType<Related>['columns']['shape'];
@@ -92,7 +92,7 @@ export const createModel = <CT extends ColumnTypesBase>(options: {
 
     hasOne<
       Self extends this,
-      Related extends ModelClass,
+      Related extends TableClass,
       Scope extends Query,
       Through extends string,
       Source extends string,
@@ -120,7 +120,7 @@ export const createModel = <CT extends ColumnTypesBase>(options: {
 
     hasMany<
       Self extends this,
-      Related extends ModelClass,
+      Related extends TableClass,
       Scope extends Query,
       Through extends string,
       Source extends string,
@@ -148,7 +148,7 @@ export const createModel = <CT extends ColumnTypesBase>(options: {
 
     hasAndBelongsToMany<
       Self extends this,
-      Related extends ModelClass,
+      Related extends TableClass,
       Scope extends Query,
       Options extends {
         primaryKey: keyof Self['columns']['shape'];

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

@@ -1,13 +1,13 @@
 import { orchidORM } from '../orm';
 import {
-  ChatModel,
-  MessageModel,
-  PostModel,
-  PostTagModel,
-  ProfileModel,
-  TagModel,
-  UserModel,
-} from './test-models';
+  ChatTable,
+  MessageTable,
+  PostTable,
+  PostTagTable,
+  ProfileTable,
+  TagTable,
+  UserTable,
+} from './test-tables';
 
 export const pgConfig = {
   databaseURL: process.env.DATABASE_URL,
@@ -19,13 +19,13 @@ export const db = orchidORM(
     log: false,
   },
   {
-    user: UserModel,
-    profile: ProfileModel,
-    chat: ChatModel,
-    message: MessageModel,
-    post: PostModel,
-    postTag: PostTagModel,
-    tag: TagModel,
+    user: UserTable,
+    profile: ProfileTable,
+    chat: ChatTable,
+    message: MessageTable,
+    post: PostTable,
+    postTag: PostTagTable,
+    tag: TagTable,
   },
 );
 

package/src/test-utils/{test-models.ts → test-tables.ts}

@@ -1,8 +1,8 @@
-import { createModel } from '../model';
+import { createBaseTable } from '../table';
 import { columnTypes } from 'pqb';
-import { modelToZod } from 'orchid-orm-schema-to-zod';
+import { tableToZod } from 'orchid-orm-schema-to-zod';
 
-export const Model = createModel({
+export const BaseTable = createBaseTable({
   columnTypes: {
     ...columnTypes,
     text: (min = 0, max = Infinity) => columnTypes.text(min, max),
@@ -12,8 +12,8 @@ export const Model = createModel({
   },
 });
 
-export type User = UserModel['columns']['type'];
-export class UserModel extends Model {
+export type User = UserTable['columns']['type'];
+export class UserTable extends BaseTable {
   table = 'user';
   columns = this.setColumns((t) => ({
     id: t.serial().primaryKey(),
@@ -34,18 +34,18 @@ export class UserModel extends Model {
   }));
 
   relations = {
-    profile: this.hasOne(() => ProfileModel, {
+    profile: this.hasOne(() => ProfileTable, {
       required: true,
       primaryKey: 'id',
       foreignKey: 'userId',
     }),
 
-    messages: this.hasMany(() => MessageModel, {
+    messages: this.hasMany(() => MessageTable, {
       primaryKey: 'id',
       foreignKey: 'authorId',
     }),
 
-    chats: this.hasAndBelongsToMany(() => ChatModel, {
+    chats: this.hasAndBelongsToMany(() => ChatTable, {
       primaryKey: 'id',
       foreignKey: 'userId',
       associationPrimaryKey: 'id',
@@ -54,38 +54,38 @@ export class UserModel extends Model {
     }),
   };
 }
-export const UserSchema = modelToZod(UserModel);
+export const UserSchema = tableToZod(UserTable);
 
-export type Profile = ProfileModel['columns']['type'];
-export class ProfileModel extends Model {
+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(() => UserModel, 'id'),
+      .foreignKey(() => UserTable, 'id'),
     bio: t.text().nullable(),
     ...t.timestamps(),
   }));
 
   relations = {
-    user: this.belongsTo(() => UserModel, {
+    user: this.belongsTo(() => UserTable, {
       required: true,
       primaryKey: 'id',
       foreignKey: 'userId',
     }),
 
-    chats: this.hasMany(() => ChatModel, {
+    chats: this.hasMany(() => ChatTable, {
       through: 'user',
       source: 'chats',
     }),
   };
 }
-export const ProfileSchema = modelToZod(ProfileModel);
+export const ProfileSchema = tableToZod(ProfileTable);
 
-export type Chat = ChatModel['columns']['type'];
-export class ChatModel extends Model {
+export type Chat = ChatTable['columns']['type'];
+export class ChatTable extends BaseTable {
   table = 'chat';
   columns = this.setColumns((t) => ({
     id: t.serial().primaryKey(),
@@ -94,7 +94,7 @@ export class ChatModel extends Model {
   }));
 
   relations = {
-    users: this.hasAndBelongsToMany(() => UserModel, {
+    users: this.hasAndBelongsToMany(() => UserTable, {
       primaryKey: 'id',
       foreignKey: 'chatId',
       associationPrimaryKey: 'id',
@@ -102,92 +102,92 @@ export class ChatModel extends Model {
       joinTable: 'chatUser',
     }),
 
-    profiles: this.hasMany(() => ProfileModel, {
+    profiles: this.hasMany(() => ProfileTable, {
       through: 'users',
       source: 'profile',
     }),
 
-    messages: this.hasMany(() => MessageModel, {
+    messages: this.hasMany(() => MessageTable, {
       primaryKey: 'id',
       foreignKey: 'chatId',
     }),
   };
 }
-export const ChatSchema = modelToZod(ChatModel);
+export const ChatSchema = tableToZod(ChatTable);
 
-export type Message = MessageModel['columns']['type'];
-export class MessageModel extends Model {
+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(() => ChatModel, 'id'),
+    chatId: t.integer().foreignKey(() => ChatTable, 'id'),
     authorId: t
       .integer()
       .nullable()
-      .foreignKey(() => UserModel, 'id'),
+      .foreignKey(() => UserTable, 'id'),
     text: t.text(),
     ...t.timestamps(),
   }));
 
   relations = {
-    user: this.belongsTo(() => UserModel, {
+    user: this.belongsTo(() => UserTable, {
       primaryKey: 'id',
       foreignKey: 'authorId',
     }),
 
-    chat: this.belongsTo(() => ChatModel, {
+    chat: this.belongsTo(() => ChatTable, {
       primaryKey: 'id',
       foreignKey: 'chatId',
     }),
 
-    profile: this.hasOne(() => ProfileModel, {
+    profile: this.hasOne(() => ProfileTable, {
       required: true,
       through: 'user',
       source: 'profile',
     }),
   };
 }
-export const MessageSchema = modelToZod(MessageModel);
+export const MessageSchema = tableToZod(MessageTable);
 
-export type Post = PostModel['columns']['type'];
-export class PostModel extends Model {
+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(() => UserModel, 'id'),
+    userId: t.integer().foreignKey(() => UserTable, 'id'),
     title: t.text(),
     ...t.timestamps(),
   }));
 
   relations = {
-    postTags: this.hasMany(() => PostTagModel, {
+    postTags: this.hasMany(() => PostTagTable, {
       primaryKey: 'id',
       foreignKey: 'postId',
     }),
   };
 }
-export const PostSchema = modelToZod(PostModel);
+export const PostSchema = tableToZod(PostTable);
 
-export type PostTag = PostTagModel['columns']['type'];
-export class PostTagModel extends Model {
+export type PostTag = PostTagTable['columns']['type'];
+export class PostTagTable extends BaseTable {
   table = 'postTag';
   columns = this.setColumns((t) => ({
-    postId: t.integer().foreignKey(() => PostModel, 'id'),
-    tag: t.text().foreignKey(() => TagModel, 'tag'),
+    postId: t.integer().foreignKey(() => PostTable, 'id'),
+    tag: t.text().foreignKey(() => TagTable, 'tag'),
     ...t.primaryKey(['postId', 'tag']),
   }));
 
   relations = {
-    tag: this.belongsTo(() => TagModel, {
+    tag: this.belongsTo(() => TagTable, {
       primaryKey: 'tag',
       foreignKey: 'tag',
     }),
   };
 }
-export const PostTagSchema = modelToZod(PostTagModel);
+export const PostTagSchema = tableToZod(PostTagTable);
 
-export type Tag = TagModel['columns']['type'];
-export class TagModel extends Model {
+export type Tag = TagTable['columns']['type'];
+export class TagTable extends BaseTable {
   table = 'tag';
   columns = this.setColumns((t) => ({
     tag: t.text().primaryKey(),

package/src/transaction.test.ts

@@ -4,7 +4,7 @@ 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 () => {
+  it('should have override transaction method which implicitly connects tables with a single transaction', async () => {
     const spy = jest.spyOn(Client.prototype, 'query');
 
     await db

package/src/transaction.ts

@@ -13,10 +13,10 @@ export function transaction<T extends { $queryBuilder: Db }, Result>(
     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;
+        const table = value.transacting(q);
+        table.__table = table;
+        (table as unknown as { db: unknown }).db = orm;
+        orm[key] = table;
       } else {
         orm[key] = value;
       }

package/src/utils.ts

@@ -0,0 +1,9 @@
+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

@@ -7,6 +7,7 @@
     "baseUrl": ".",
     "paths": {
       "pqb": ["../pqb/src"],
+      "rake-db": ["../rake-db/src"],
       "orchid-orm-schema-to-zod": ["../schema-to-zod/src"]
     }
   }