orchid-orm 1.3.16 → 1.4.17

package/src/orm.test.ts

@@ -6,21 +6,21 @@ import {
   useTestDatabase,
 } from './test-utils/test-utils';
 import { pgConfig } from './test-utils/test-db';
-import { createModel } from './model';
+import { createBaseTable } from './table';
 import { columnTypes } from 'pqb';
 
 describe('orm', () => {
   useTestDatabase();
 
-  const Model = createModel({
+  const BaseTable = createBaseTable({
     columnTypes: {
       ...columnTypes,
       text: (min = 0, max = Infinity) => columnTypes.text(min, max),
     },
   });
 
-  type User = UserModel['columns']['type'];
-  class UserModel extends Model {
+  type User = UserTable['columns']['type'];
+  class UserTable extends BaseTable {
     table = 'user';
     columns = this.setColumns((t) => ({
       id: t.serial().primaryKey(),
@@ -29,17 +29,17 @@ describe('orm', () => {
     }));
   }
 
-  class ProfileModel extends Model {
+  class ProfileTable extends BaseTable {
     table = 'profile';
     columns = this.setColumns((t) => ({
       id: t.serial().primaryKey(),
     }));
   }
 
-  it('should return object with provided adapter, close and transaction method, models', () => {
+  it('should return object with provided adapter, close and transaction method, tables', () => {
     const db = orchidORM(pgConfig, {
-      user: UserModel,
-      profile: ProfileModel,
+      user: UserTable,
+      profile: ProfileTable,
     });
 
     expect('$adapter' in db).toBe(true);
@@ -50,10 +50,10 @@ describe('orm', () => {
     );
   });
 
-  it('should return model which is a queryable interface', async () => {
+  it('should return table which is a queryable interface', async () => {
     const db = orchidORM(pgConfig, {
-      user: UserModel,
-      profile: ProfileModel,
+      user: UserTable,
+      profile: ProfileTable,
     });
 
     const { id, name } = await db.user.create(userData);
@@ -80,8 +80,8 @@ describe('orm', () => {
     const db = orchidORM(
       { ...pgConfig, autoPreparedStatements: true },
       {
-        user: UserModel,
-        profile: ProfileModel,
+        user: UserTable,
+        profile: ProfileTable,
       },
     );
 

package/src/orm.ts

@@ -8,12 +8,12 @@ import {
   anyShape,
   DbTableOptions,
 } from 'pqb';
-import { DbModel, Model, ModelClasses } from './model';
+import { DbTable, Table, TableClasses } from './table';
 import { applyRelations } from './relations/relations';
 import { transaction } from './transaction';
 
-export type OrchidORM<T extends ModelClasses> = {
-  [K in keyof T]: DbModel<T[K]>;
+export type OrchidORM<T extends TableClasses> = {
+  [K in keyof T]: DbTable<T[K]>;
 } & {
   $transaction: typeof transaction;
   $adapter: Adapter;
@@ -21,7 +21,7 @@ export type OrchidORM<T extends ModelClasses> = {
   $close(): Promise<void>;
 };
 
-export const orchidORM = <T extends ModelClasses>(
+export const orchidORM = <T extends TableClasses>(
   {
     log,
     logger,
@@ -33,7 +33,7 @@ export const orchidORM = <T extends ModelClasses>(
       autoPreparedStatements?: boolean;
       noPrimaryKey?: NoPrimaryKeyOption;
     },
-  models: T,
+  tables: T,
 ): OrchidORM<T> => {
   const adapter = 'adapter' in options ? options.adapter : new Adapter(options);
   const commonOptions = {
@@ -57,42 +57,42 @@ export const orchidORM = <T extends ModelClasses>(
     $adapter: adapter,
     $queryBuilder: qb,
     $close: () => adapter.close(),
-  } as unknown as OrchidORM<ModelClasses>;
+  } as unknown as OrchidORM<TableClasses>;
 
-  const modelInstances: Record<string, Model> = {};
+  const tableInstances: Record<string, Table> = {};
 
-  for (const key in models) {
+  for (const key in tables) {
     if (key[0] === '$') {
-      throw new Error(`Model name must not start with $`);
+      throw new Error(`Table class name must not start with $`);
     }
 
-    const model = new models[key]();
-    modelInstances[key] = model;
+    const table = new tables[key]();
+    tableInstances[key] = table;
 
     const options: DbTableOptions = {
       ...commonOptions,
-      schema: model.schema,
+      schema: table.schema,
     };
 
-    if (model.noPrimaryKey) options.noPrimaryKey = 'ignore';
+    if (table.noPrimaryKey) options.noPrimaryKey = 'ignore';
 
-    const dbModel = new Db(
+    const dbTable = new Db(
       adapter,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       qb as any,
-      model.table,
-      model.columns.shape,
-      model.columnTypes,
+      table.table,
+      table.columns.shape,
+      table.columnTypes,
       options,
     );
 
-    (dbModel as unknown as { definedAs: string }).definedAs = key;
-    (dbModel as unknown as { db: unknown }).db = result;
+    (dbTable as unknown as { definedAs: string }).definedAs = key;
+    (dbTable as unknown as { db: unknown }).db = result;
 
-    (result as Record<string, unknown>)[key] = dbModel;
+    (result as Record<string, unknown>)[key] = dbTable;
   }
 
-  applyRelations(qb, modelInstances, result);
+  applyRelations(qb, tableInstances, result);
 
   return result as unknown as OrchidORM<T>;
 };

package/src/relations/belongsTo.test.ts

@@ -10,7 +10,7 @@ import {
   useTestDatabase,
 } from '../test-utils/test-utils';
 import { RelationQuery } from 'pqb';
-import { User } from '../test-utils/test-models';
+import { User } from '../test-utils/test-tables';
 
 describe('belongsTo', () => {
   useTestDatabase();

package/src/relations/belongsTo.ts

@@ -1,4 +1,4 @@
-import { Model } from '../model';
+import { Table } from '../table';
 import {
   addQueryOn,
   BelongsToRelation,
@@ -23,7 +23,7 @@ export interface BelongsTo extends RelationThunkBase {
 }
 
 export type BelongsToInfo<
-  T extends Model,
+  T extends Table,
   Relation extends BelongsTo,
   FK extends string = Relation['options']['foreignKey'],
 > = {

package/src/relations/hasAndBelongsToMany.test.ts

@@ -9,7 +9,7 @@ import {
   useRelationCallback,
 } from '../test-utils/test-utils';
 import { RelationQuery, Sql, TransactionAdapter } from 'pqb';
-import { Chat, User } from '../test-utils/test-models';
+import { Chat, User } from '../test-utils/test-tables';
 
 describe('hasAndBelongsToMany', () => {
   useTestDatabase();

package/src/relations/hasAndBelongsToMany.ts

@@ -1,5 +1,5 @@
 import { RelationData, RelationThunkBase } from './relations';
-import { Model } from '../model';
+import { Table } from '../table';
 import {
   CreateCtx,
   getQueryAs,
@@ -25,7 +25,7 @@ export interface HasAndBelongsToMany extends RelationThunkBase {
 }
 
 export type HasAndBelongsToManyInfo<
-  T extends Model,
+  T extends Table,
   Relation extends HasAndBelongsToMany,
 > = {
   params: Record<
@@ -89,7 +89,7 @@ class HasAndBelongsToManyVirtualColumn extends VirtualColumn {
 }
 
 export const makeHasAndBelongsToManyMethod = (
-  model: Query,
+  table: Query,
   qb: Query,
   relation: HasAndBelongsToMany,
   relationName: string,
@@ -107,14 +107,14 @@ export const makeHasAndBelongsToManyMethod = (
   const associationForeignKeyFull = `${joinTable}.${afk}`;
   const associationPrimaryKeyFull = `${getQueryAs(query)}.${apk}`;
 
-  const __model = Object.create(qb.__model);
-  __model.__model = __model;
-  __model.table = joinTable;
-  __model.shape = {
-    [fk]: model.shape[pk],
+  const __table = Object.create(qb.__table);
+  __table.__table = __table;
+  __table.table = joinTable;
+  __table.shape = {
+    [fk]: table.shape[pk],
     [afk]: query.shape[apk],
   };
-  const subQuery = Object.create(__model);
+  const subQuery = Object.create(__table);
   subQuery.query = { ...subQuery.query };
 
   const state: State = {

package/src/relations/hasMany.test.ts

@@ -9,7 +9,13 @@ import {
   useTestDatabase,
 } from '../test-utils/test-utils';
 import { RelationQuery } from 'pqb';
-import { Chat, Message, Model, Profile, User } from '../test-utils/test-models';
+import {
+  Chat,
+  Message,
+  BaseTable,
+  Profile,
+  User,
+} from '../test-utils/test-tables';
 import { orchidORM } from '../orm';
 
 describe('hasMany', () => {
@@ -1653,8 +1659,8 @@ describe('hasMany', () => {
 });
 
 describe('hasMany through', () => {
-  it('should resolve recursive situation when both models depends on each other', () => {
-    class Post extends Model {
+  it('should resolve recursive situation when both tables depends on each other', () => {
+    class Post extends BaseTable {
       table = 'post';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1673,7 +1679,7 @@ describe('hasMany through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1692,7 +1698,7 @@ describe('hasMany through', () => {
       };
     }
 
-    class PostTag extends Model {
+    class PostTag extends BaseTable {
       table = 'postTag';
       columns = this.setColumns((t) => ({
         postId: t.integer().foreignKey(() => Post, 'id'),
@@ -1730,7 +1736,7 @@ describe('hasMany through', () => {
   });
 
   it('should throw if through relation is not defined', () => {
-    class Post extends Model {
+    class Post extends BaseTable {
       table = 'post';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1744,7 +1750,7 @@ describe('hasMany through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1768,7 +1774,7 @@ describe('hasMany through', () => {
   });
 
   it('should throw if source relation is not defined', () => {
-    class Post extends Model {
+    class Post extends BaseTable {
       table = 'post';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1787,14 +1793,14 @@ describe('hasMany through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
       }));
     }
 
-    class PostTag extends Model {
+    class PostTag extends BaseTable {
       table = 'postTag';
       columns = this.setColumns((t) => ({
         postId: t.integer().foreignKey(() => Post, 'id'),

package/src/relations/hasMany.ts

@@ -4,7 +4,7 @@ import {
   RelationThunkBase,
   RelationThunks,
 } from './relations';
-import { Model } from '../model';
+import { Table } from '../table';
 import {
   addQueryOn,
   getQueryAs,
@@ -39,7 +39,7 @@ export interface HasMany extends RelationThunkBase {
 }
 
 export type HasManyInfo<
-  T extends Model,
+  T extends Table,
   Relations extends RelationThunks,
   Relation extends HasMany,
 > = {
@@ -124,7 +124,7 @@ class HasManyVirtualColumn extends VirtualColumn {
 }
 
 export const makeHasManyMethod = (
-  model: Query,
+  table: Query,
   relation: HasMany,
   relationName: string,
   query: Query,
@@ -132,12 +132,12 @@ export const makeHasManyMethod = (
   if ('through' in relation.options) {
     const { through, source } = relation.options;
 
-    type ModelWithQueryMethod = Record<
+    type TableWithQueryMethod = Record<
       string,
       (params: Record<string, unknown>) => Query
     >;
 
-    const throughRelation = getThroughRelation(model, through);
+    const throughRelation = getThroughRelation(table, through);
     const sourceRelation = getSourceRelation(throughRelation, source);
     const sourceRelationQuery = sourceRelation.query.as(relationName);
     const sourceQuery = sourceRelation.joinQuery(
@@ -150,7 +150,7 @@ export const makeHasManyMethod = (
     return {
       returns: 'many',
       method: (params: Record<string, unknown>) => {
-        const throughQuery = (model as unknown as ModelWithQueryMethod)[
+        const throughQuery = (table as unknown as TableWithQueryMethod)[
           through
         ](params);
 

package/src/relations/hasOne.test.ts

@@ -8,7 +8,7 @@ import {
   useRelationCallback,
   useTestDatabase,
 } from '../test-utils/test-utils';
-import { User, Profile, Model } from '../test-utils/test-models';
+import { User, Profile, BaseTable } from '../test-utils/test-tables';
 import { RelationQuery } from 'pqb';
 import { orchidORM } from '../orm';
 
@@ -1264,8 +1264,8 @@ describe('hasOne', () => {
 });
 
 describe('hasOne through', () => {
-  it('should resolve recursive situation when both models depends on each other', () => {
-    class Post extends Model {
+  it('should resolve recursive situation when both tables depends on each other', () => {
+    class Post extends BaseTable {
       table = 'post';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1284,7 +1284,7 @@ describe('hasOne through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1303,7 +1303,7 @@ describe('hasOne through', () => {
       };
     }
 
-    class PostTag extends Model {
+    class PostTag extends BaseTable {
       table = 'postTag';
       columns = this.setColumns((t) => ({
         postId: t.integer().foreignKey(() => Post, 'id'),
@@ -1341,7 +1341,7 @@ describe('hasOne through', () => {
   });
 
   it('should throw if through relation is not defined', () => {
-    class Post extends Model {
+    class Post extends BaseTable {
       table = 'post';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1355,7 +1355,7 @@ describe('hasOne through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1379,7 +1379,7 @@ describe('hasOne through', () => {
   });
 
   it('should throw if source relation is not defined', () => {
-    class Post extends Model {
+    class Post extends BaseTable {
       table = 'post';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
@@ -1398,14 +1398,14 @@ describe('hasOne through', () => {
       };
     }
 
-    class Tag extends Model {
+    class Tag extends BaseTable {
       table = 'tag';
       columns = this.setColumns((t) => ({
         id: t.serial().primaryKey(),
       }));
     }
 
-    class PostTag extends Model {
+    class PostTag extends BaseTable {
       table = 'postTag';
       columns = this.setColumns((t) => ({
         postId: t.integer().foreignKey(() => Post, 'id'),

package/src/relations/hasOne.ts

@@ -13,7 +13,7 @@ import {
   WhereArg,
   WhereResult,
 } from 'pqb';
-import { Model } from '../model';
+import { Table } from '../table';
 import {
   RelationData,
   RelationInfo,
@@ -36,7 +36,7 @@ export interface HasOne extends RelationThunkBase {
 }
 
 export type HasOneInfo<
-  T extends Model,
+  T extends Table,
   Relations extends RelationThunks,
   Relation extends HasOne,
 > = {
@@ -121,7 +121,7 @@ class HasOneVirtualColumn extends VirtualColumn {
 }
 
 export const makeHasOneMethod = (
-  model: Query,
+  table: Query,
   relation: HasOne,
   relationName: string,
   query: Query,
@@ -135,12 +135,12 @@ export const makeHasOneMethod = (
   if ('through' in relation.options) {
     const { through, source } = relation.options;
 
-    type ModelWithQueryMethod = Record<
+    type TableWithQueryMethod = Record<
       string,
       (params: Record<string, unknown>) => Query
     >;
 
-    const throughRelation = getThroughRelation(model, through);
+    const throughRelation = getThroughRelation(table, through);
     const sourceRelation = getSourceRelation(throughRelation, source);
     const sourceQuery = sourceRelation
       .joinQuery(throughRelation.query, sourceRelation.query)
@@ -151,7 +151,7 @@ export const makeHasOneMethod = (
     return {
       returns: 'one',
       method: (params: Record<string, unknown>) => {
-        const throughQuery = (model as unknown as ModelWithQueryMethod)[
+        const throughQuery = (table as unknown as TableWithQueryMethod)[
           through
         ](params);