orchid-orm 1.3.16 → 1.4.16

package/src/relations/relations.ts

@@ -1,6 +1,6 @@
 import { BelongsTo, BelongsToInfo, makeBelongsToMethod } from './belongsTo';
 import { HasOne, HasOneInfo, makeHasOneMethod } from './hasOne';
-import { DbModel, Model, ModelClass, ModelClasses } from '../model';
+import { DbTable, Table, TableClass, TableClasses } from '../table';
 import { OrchidORM } from '../orm';
 import {
   Query,
@@ -26,7 +26,7 @@ import { getSourceRelation, getThroughRelation } from './utils';
 export interface RelationThunkBase {
   type: string;
   returns: 'one' | 'many';
-  fn(): ModelClass;
+  fn(): TableClass;
   options: BaseRelation['options'];
 }
 
@@ -45,16 +45,16 @@ export type RelationData = {
 };
 
 export type Relation<
-  T extends Model,
+  T extends Table,
   Relations extends RelationThunks,
   K extends keyof Relations,
-  M extends Query = DbModel<ReturnType<Relations[K]['fn']>>,
+  M extends Query = DbTable<ReturnType<Relations[K]['fn']>>,
   Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>,
 > = {
   type: Relations[K]['type'];
   returns: Relations[K]['returns'];
   key: K;
-  model: M;
+  table: M;
   query: M;
   joinQuery(fromQuery: Query, toQuery: Query): Query;
   defaults: Info['populate'];
@@ -67,13 +67,13 @@ export type Relation<
   options: Relations[K]['options'];
 };
 
-export type RelationScopeOrModel<Relation extends RelationThunkBase> =
+export type RelationScopeOrTable<Relation extends RelationThunkBase> =
   Relation['options']['scope'] extends (q: Query) => Query
     ? ReturnType<Relation['options']['scope']>
-    : DbModel<ReturnType<Relation['fn']>>;
+    : DbTable<ReturnType<Relation['fn']>>;
 
 export type RelationInfo<
-  T extends Model = Model,
+  T extends Table = Table,
   Relations extends RelationThunks = RelationThunks,
   Relation extends RelationThunk = RelationThunk,
 > = Relation extends BelongsTo
@@ -87,11 +87,11 @@ export type RelationInfo<
   : never;
 
 export type MapRelation<
-  T extends Model,
+  T extends Table,
   Relations extends RelationThunks,
   RelationName extends keyof Relations,
   Relation extends RelationThunk = Relations[RelationName],
-  RelatedQuery extends Query = RelationScopeOrModel<Relation>,
+  RelatedQuery extends Query = RelationScopeOrTable<Relation>,
   Info extends {
     params: Record<string, unknown>;
     populate: string;
@@ -114,7 +114,7 @@ export type MapRelation<
   Info['chainedDelete']
 >;
 
-export type MapRelations<T extends Model> = 'relations' extends keyof T
+export type MapRelations<T extends Table> = 'relations' extends keyof T
   ? T['relations'] extends RelationThunks
     ? {
         [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
@@ -125,48 +125,50 @@ export type MapRelations<T extends Model> = 'relations' extends keyof T
 type ApplyRelationData = {
   relationName: string;
   relation: RelationThunk;
-  dbModel: DbModel<ModelClass>;
-  otherDbModel: DbModel<ModelClass>;
+  dbTable: DbTable<TableClass>;
+  otherDbTable: DbTable<TableClass>;
 };
 
 type DelayedRelations = Map<Query, Record<string, ApplyRelationData[]>>;
 
 export const applyRelations = (
   qb: Query,
-  models: Record<string, Model>,
-  result: OrchidORM<ModelClasses>,
+  tables: Record<string, Table>,
+  result: OrchidORM<TableClasses>,
 ) => {
-  const modelsEntries = Object.entries(models);
+  const tableEntries = Object.entries(tables);
 
   const delayedRelations: DelayedRelations = new Map();
 
-  for (const modelName in models) {
-    const model = models[modelName] as Model & {
+  for (const name in tables) {
+    const table = tables[name] as Table & {
       relations?: RelationThunks;
     };
-    if (!('relations' in model) || typeof model.relations !== 'object')
+    if (!('relations' in table) || typeof table.relations !== 'object')
       continue;
 
-    const dbModel = result[modelName];
-    for (const relationName in model.relations) {
-      const relation = model.relations[relationName];
-      const otherModelClass = relation.fn();
-      const otherModel = modelsEntries.find(
-        (pair) => pair[1] instanceof otherModelClass,
+    const dbTable = result[name];
+    for (const relationName in table.relations) {
+      const relation = table.relations[relationName];
+      const otherTableClass = relation.fn();
+      const otherTable = tableEntries.find(
+        (pair) => pair[1] instanceof otherTableClass,
       );
-      if (!otherModel) {
-        throw new Error(`Cannot find model for class ${otherModelClass.name}`);
+      if (!otherTable) {
+        throw new Error(
+          `Cannot find table class for class ${otherTableClass.name}`,
+        );
       }
-      const otherModelName = otherModel[0];
-      const otherDbModel = result[otherModelName];
-      if (!otherDbModel)
-        throw new Error(`Cannot find model by name ${otherModelName}`);
+      const otherTableName = otherTable[0];
+      const otherDbTable = result[otherTableName];
+      if (!otherDbTable)
+        throw new Error(`Cannot find table class by name ${otherTableName}`);
 
       const data: ApplyRelationData = {
         relationName,
         relation,
-        dbModel,
-        otherDbModel,
+        dbTable,
+        otherDbTable,
       };
 
       const options = relation.options as { through?: string; source?: string };
@@ -174,9 +176,9 @@ export const applyRelations = (
         typeof options.through === 'string' &&
         typeof options.source === 'string'
       ) {
-        const throughRelation = getThroughRelation(dbModel, options.through);
+        const throughRelation = getThroughRelation(dbTable, options.through);
         if (!throughRelation) {
-          delayRelation(delayedRelations, dbModel, options.through, data);
+          delayRelation(delayedRelations, dbTable, options.through, data);
           continue;
         }
 
@@ -187,7 +189,7 @@ export const applyRelations = (
         if (!sourceRelation) {
           delayRelation(
             delayedRelations,
-            throughRelation.model,
+            throughRelation.table,
             options.source,
             data,
           );
@@ -207,17 +209,17 @@ export const applyRelations = (
       for (const item of value[key]) {
         const { relation } = item;
 
-        if (item.dbModel.relations[item.relationName as never]) continue;
+        if (item.dbTable.relations[item.relationName as never]) continue;
 
-        const as = item.dbModel.definedAs;
+        const as = item.dbTable.definedAs;
         let message = `Cannot define a \`${item.relationName}\` relation on \`${as}\``;
-        const model = result[as];
+        const table = result[as];
 
         const { through, source } = relation.options as {
           through: string;
           source: string;
         };
-        const throughRel = model.relations[
+        const throughRel = table.relations[
           through as never
         ] as unknown as BaseRelation;
 
@@ -226,10 +228,10 @@ export const applyRelations = (
         } else if (
           source &&
           throughRel &&
-          !throughRel.model.relations[source as never]
+          !throughRel.table.relations[source as never]
         ) {
           message += `: cannot find \`${source}\` relation in \`${
-            (throughRel.model as DbModel<ModelClass>).definedAs
+            (throughRel.table as DbTable<TableClass>).definedAs
           }\` required by the \`source\` option`;
         }
 
@@ -241,37 +243,37 @@ export const applyRelations = (
 
 const delayRelation = (
   delayedRelations: DelayedRelations,
-  model: Query,
+  table: Query,
   relationName: string,
   data: ApplyRelationData,
 ) => {
-  let modelRelations = delayedRelations.get(model);
-  if (!modelRelations) {
-    modelRelations = {};
-    delayedRelations.set(model, modelRelations);
+  let tableRelations = delayedRelations.get(table);
+  if (!tableRelations) {
+    tableRelations = {};
+    delayedRelations.set(table, tableRelations);
   }
-  if (modelRelations[relationName]) {
-    modelRelations[relationName].push(data);
+  if (tableRelations[relationName]) {
+    tableRelations[relationName].push(data);
   } else {
-    modelRelations[relationName] = [data];
+    tableRelations[relationName] = [data];
   }
 };
 
 const applyRelation = (
   qb: Query,
-  { relationName, relation, dbModel, otherDbModel }: ApplyRelationData,
+  { relationName, relation, dbTable, otherDbTable }: ApplyRelationData,
   delayedRelations: DelayedRelations,
 ) => {
   const query = (
     relation.options.scope
-      ? relation.options.scope(otherDbModel)
-      : (otherDbModel as unknown as QueryWithTable)
+      ? relation.options.scope(otherDbTable)
+      : (otherDbTable as unknown as QueryWithTable)
   ).as(relationName);
 
   const definedAs = (query as unknown as { definedAs?: string }).definedAs;
   if (!definedAs) {
     throw new Error(
-      `Model for table ${query.table} is not attached to db instance`,
+      `Table class for table ${query.table} is not attached to db instance`,
     );
   }
 
@@ -280,12 +282,12 @@ const applyRelation = (
   if (type === 'belongsTo') {
     data = makeBelongsToMethod(relation, relationName, query);
   } else if (type === 'hasOne') {
-    data = makeHasOneMethod(dbModel, relation, relationName, query);
+    data = makeHasOneMethod(dbTable, relation, relationName, query);
   } else if (type === 'hasMany') {
-    data = makeHasManyMethod(dbModel, relation, relationName, query);
+    data = makeHasManyMethod(dbTable, relation, relationName, query);
   } else if (type === 'hasAndBelongsToMany') {
     data = makeHasAndBelongsToManyMethod(
-      dbModel,
+      dbTable,
       qb,
       relation,
       relationName,
@@ -300,51 +302,51 @@ const applyRelation = (
   }
 
   if (data.virtualColumn) {
-    dbModel.shape[relationName] = data.virtualColumn;
+    dbTable.shape[relationName] = data.virtualColumn;
   }
 
-  makeRelationQuery(dbModel, definedAs, relationName, data);
+  makeRelationQuery(dbTable, definedAs, relationName, data);
 
-  (dbModel.relations as Record<string, unknown>)[relationName] = {
+  (dbTable.relations as Record<string, unknown>)[relationName] = {
     type,
     key: relationName,
-    model: otherDbModel,
+    table: otherDbTable,
     query,
     joinQuery: data.joinQuery,
     primaryKey: data.primaryKey,
     options: relation.options,
   };
 
-  const modelRelations = delayedRelations.get(dbModel);
-  if (!modelRelations) return;
+  const tableRelations = delayedRelations.get(dbTable);
+  if (!tableRelations) return;
 
-  modelRelations[relationName]?.forEach((data) => {
+  tableRelations[relationName]?.forEach((data) => {
     applyRelation(qb, data, delayedRelations);
   });
 };
 
 const makeRelationQuery = (
-  model: Query,
+  table: Query,
   definedAs: string,
   relationName: string,
   data: RelationData,
 ) => {
-  Object.defineProperty(model, relationName, {
+  Object.defineProperty(table, relationName, {
     get() {
-      const toModel = this.db[definedAs].as(relationName) as Query;
+      const toTable = this.db[definedAs].as(relationName) as Query;
 
       if (data.returns === 'one') {
-        toModel._take();
+        toTable._take();
       }
 
       const query = this.isSubQuery
-        ? toModel
-        : toModel._whereExists(data.reverseJoin(this, toModel), (q) => q);
+        ? toTable
+        : toTable._whereExists(data.reverseJoin(this, toTable), (q) => q);
 
       query.query[relationQueryKey] = {
         relationName,
         sourceQuery: this,
-        relationQuery: toModel,
+        relationQuery: toTable,
         joinQuery: data.joinQuery,
       };
 

package/src/relations/utils.ts

@@ -57,15 +57,15 @@ export type NestedUpdateManyItems = {
 
 export type NestedUpdateItem = NestedUpdateOneItem | NestedUpdateManyItems;
 
-export const getThroughRelation = (model: Query, through: string) => {
-  return (model.relations as Record<string, Relation>)[through];
+export const getThroughRelation = (table: Query, through: string) => {
+  return (table.relations as Record<string, Relation>)[through];
 };
 
 export const getSourceRelation = (
   throughRelation: Relation,
   source: string,
 ) => {
-  return (throughRelation.model.relations as Record<string, Relation>)[source];
+  return (throughRelation.table.relations as Record<string, Relation>)[source];
 };
 
 export const hasRelationHandleCreate = (

package/src/repo.test.ts

@@ -1,63 +1,63 @@
 import { orchidORM } from './orm';
 import { pgConfig } from './test-utils/test-db';
-import { createModel } from './model';
+import { createBaseTable } from './table';
 import { assertType, expectSql } from './test-utils/test-utils';
 import { columnTypes, QueryReturnType } from 'pqb';
 import { createRepo } from './repo';
 
-const Model = createModel({ columnTypes });
+const BaseTable = createBaseTable({ columnTypes });
 
-class SomeModel extends Model {
+class SomeTable extends BaseTable {
   table = 'someTable';
   columns = this.setColumns((t) => ({
     id: t.serial().primaryKey(),
-    name: t.text(),
+    name: t.text(0, 100),
   }));
 
   relations = {
-    otherModel: this.hasMany(() => OtherModel, {
+    other: this.hasMany(() => OtherTable, {
       primaryKey: 'id',
       foreignKey: 'someId',
     }),
   };
 }
 
-class OtherModel extends Model {
+class OtherTable extends BaseTable {
   table = 'otherTable';
   columns = this.setColumns((t) => ({
     id: t.serial().primaryKey(),
-    someId: t.integer().foreignKey(() => SomeModel, 'id'),
-    anotherId: t.integer().foreignKey(() => AnotherModel, 'id'),
+    someId: t.integer().foreignKey(() => SomeTable, 'id'),
+    anotherId: t.integer().foreignKey(() => AnotherTable, 'id'),
   }));
 
   relations = {
-    someModel: this.belongsTo(() => SomeModel, {
+    some: this.belongsTo(() => SomeTable, {
       primaryKey: 'id',
       foreignKey: 'someId',
     }),
-    anotherModel: this.belongsTo(() => AnotherModel, {
+    another: this.belongsTo(() => AnotherTable, {
       primaryKey: 'id',
       foreignKey: 'anotherId',
     }),
   };
 }
 
-class AnotherModel extends Model {
-  table = 'anotherModel';
+class AnotherTable extends BaseTable {
+  table = 'another';
   columns = this.setColumns((t) => ({
     id: t.serial().primaryKey(),
   }));
 }
 
 const db = orchidORM(pgConfig, {
-  someModel: SomeModel,
-  otherModel: OtherModel,
-  anotherModel: AnotherModel,
+  some: SomeTable,
+  other: OtherTable,
+  another: AnotherTable,
 });
 
 describe('createRepo', () => {
   describe('queryMethods', () => {
-    const repo = createRepo(db.someModel, {
+    const repo = createRepo(db.some, {
       queryMethods: {
         one(q) {
           return q.select('id');
@@ -71,7 +71,7 @@ describe('createRepo', () => {
       },
     });
 
-    it('should accept user defined methods and allow to use them on the model with chaining', async () => {
+    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 }>();
@@ -89,13 +89,13 @@ describe('createRepo', () => {
     });
 
     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),
+      const q = db.other.select('id', {
+        some: (q) => repo(q.some).one().two().three(123),
       });
 
       assertType<
         Awaited<typeof q>,
-        { id: number; someModel: { id: number; name: string } | null }[]
+        { id: number; some: { id: number; name: string } | null }[]
       >();
 
       expectSql(
@@ -106,13 +106,13 @@ describe('createRepo', () => {
             (
               SELECT row_to_json("t".*)
               FROM (
-                SELECT "someModel"."id", "someModel"."name"
-                FROM "someTable" AS "someModel"
-                WHERE "someModel"."id" = $1
-                  AND "someModel"."id" = "otherTable"."someId"
+                SELECT "some"."id", "some"."name"
+                FROM "someTable" AS "some"
+                WHERE "some"."id" = $1
+                  AND "some"."id" = "otherTable"."someId"
                 LIMIT $2
               ) AS "t"
-            ) AS "someModel"
+            ) AS "some"
           FROM "otherTable"
         `,
         [123, 1],
@@ -121,7 +121,7 @@ describe('createRepo', () => {
   });
 
   describe('queryOneMethods', () => {
-    const repo = createRepo(db.someModel, {
+    const repo = createRepo(db.some, {
       queryOneMethods: {
         one(q) {
           const type: Exclude<QueryReturnType, 'all'> = q.returnType;
@@ -140,7 +140,7 @@ describe('createRepo', () => {
   });
 
   describe('queryWithWhereMethods', () => {
-    const repo = createRepo(db.someModel, {
+    const repo = createRepo(db.some, {
       queryWithWhereMethods: {
         one(q) {
           const hasWhere: true = q.hasWhere;
@@ -161,7 +161,7 @@ describe('createRepo', () => {
   });
 
   describe('queryOneWithWhere', () => {
-    const repo = createRepo(db.someModel, {
+    const repo = createRepo(db.some, {
       queryOneWithWhereMethods: {
         one(q) {
           const type: Exclude<QueryReturnType, 'all'> = q.returnType;
@@ -185,7 +185,7 @@ describe('createRepo', () => {
   });
 
   describe('methods', () => {
-    const repo = createRepo(db.someModel, {
+    const repo = createRepo(db.some, {
       methods: {
         one(a: number, b: string) {
           return a + b;

package/src/repo.ts

@@ -75,7 +75,7 @@ export type Repo<
   Mapped;
 
 export const createRepo = <T extends Query, Methods extends MethodsBase<T>>(
-  model: T,
+  table: T,
   methods: Methods,
 ): Repo<T, Methods> => {
   const queryMethods = {
@@ -88,18 +88,18 @@ export const createRepo = <T extends Query, Methods extends MethodsBase<T>>(
   const plainMethods = methods.methods;
 
   const repo = (q: Query) => {
-    const proto = Object.create(q.__model);
-    proto.__model = proto;
+    const proto = Object.create(q.__table);
+    proto.__table = proto;
     const result = Object.create(proto);
     result.query = getClonedQueryData(q.query);
 
     if (plainMethods) {
-      Object.assign(proto.__model, plainMethods);
+      Object.assign(proto.__table, plainMethods);
     }
 
     for (const key in queryMethods) {
       const method = queryMethods[key] as (...args: unknown[]) => unknown;
-      (proto.__model as unknown as Record<string, unknown>)[key] = function (
+      (proto.__table as unknown as Record<string, unknown>)[key] = function (
         ...args: unknown[]
       ) {
         return method(this, ...args);
@@ -109,7 +109,7 @@ export const createRepo = <T extends Query, Methods extends MethodsBase<T>>(
     return result;
   };
 
-  const q = repo(model);
+  const q = repo(table);
 
   return new Proxy(repo, {
     get(_, key) {

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

@@ -1,11 +1,11 @@
-import { createModel } from './model';
+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, columnTypes, Operators } from 'pqb';
-import { Model } from './test-utils/test-models';
+import { BaseTable } from './test-utils/test-tables';
 
-describe('model', () => {
+describe('table', () => {
   useTestDatabase();
 
   describe('overriding column types', () => {
@@ -15,8 +15,8 @@ describe('model', () => {
         operators = Operators.any;
       }
       const type = new Type();
-      const Model = createModel({ columnTypes: { type: () => type } });
-      class UserModel extends Model {
+      const BaseTable = createBaseTable({ columnTypes: { type: () => type } });
+      class UserTable extends BaseTable {
         table = 'user';
         columns = this.setColumns((t) => ({
           id: t.type().primaryKey(),
@@ -27,7 +27,7 @@ describe('model', () => {
       const { user } = orchidORM(
         { adapter },
         {
-          user: UserModel,
+          user: UserTable,
         },
       );
 
@@ -39,8 +39,8 @@ describe('model', () => {
     it('should return date as string by default', async () => {
       await db.user.create(userData);
 
-      const Model = createModel({ columnTypes });
-      class UserModel extends Model {
+      const BaseTable = createBaseTable({ columnTypes });
+      class UserTable extends BaseTable {
         table = 'user';
         columns = this.setColumns((t) => ({
           id: t.serial().primaryKey(),
@@ -51,7 +51,7 @@ describe('model', () => {
       const { user } = orchidORM(
         { adapter },
         {
-          user: UserModel,
+          user: UserTable,
         },
       );
 
@@ -64,7 +64,7 @@ describe('model', () => {
     it('should return date as Date when overridden', async () => {
       await db.user.create(userData);
 
-      const Model = createModel({
+      const BaseTable = createBaseTable({
         columnTypes: {
           serial: columnTypes.serial,
           timestamp() {
@@ -73,7 +73,7 @@ describe('model', () => {
         },
       });
 
-      class UserModel extends Model {
+      class UserTable extends BaseTable {
         table = 'user';
         columns = this.setColumns((t) => ({
           id: t.serial().primaryKey(),
@@ -84,7 +84,7 @@ describe('model', () => {
       const { user } = orchidORM(
         { adapter },
         {
-          user: UserModel,
+          user: UserTable,
         },
       );
 
@@ -96,8 +96,8 @@ describe('model', () => {
   });
 
   describe('noPrimaryKey', () => {
-    it('should allow to the model to not have a primary key', () => {
-      class UserModel extends Model {
+    it('should allow to the table to not have a primary key', () => {
+      class UserTable extends BaseTable {
         table = 'user';
         noPrimaryKey = true;
         columns = this.setColumns((t) => ({
@@ -110,7 +110,7 @@ describe('model', () => {
           adapter,
         },
         {
-          user: UserModel,
+          user: UserTable,
         },
       );
     });