orchid-orm 1.3.16 → 1.4.16

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # orchid-orm
 
+## 2.0.0
+
+### Minor Changes
+
+- 3f25b4d: Rename all model words to table words, because all models here are not models in OOP meaning
+
+### Patch Changes
+
+- Updated dependencies [3f25b4d]
+  - pqb@0.8.0
+  - rake-db@2.2.0
+
 ## 1.3.16
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,11 +1,12 @@
 import { BelongsToRelation, HasManyRelation, HasOneRelation, Db, Adapter, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, HasAndBelongsToManyRelation, Query, defaultsKey, EmptyObject, BaseRelation, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, ColumnTypesBase, ColumnsShape, ColumnShapeOutput, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { AppCodeUpdater } from 'rake-db';
 
 interface BelongsTo extends RelationThunkBase {
     type: 'belongsTo';
     returns: 'one';
     options: BelongsToRelation['options'];
 }
-declare type BelongsToInfo<T extends Model, Relation extends BelongsTo, FK extends string = Relation['options']['foreignKey']> = {
+declare type BelongsToInfo<T extends Table, Relation extends BelongsTo, FK extends string = Relation['options']['foreignKey']> = {
     params: Record<FK, T['columns']['shape'][FK]['type']>;
     populate: never;
     chainedCreate: false;
@@ -17,7 +18,7 @@ interface HasMany extends RelationThunkBase {
     returns: 'many';
     options: HasManyRelation['options'];
 }
-declare type HasManyInfo<T extends Model, Relations extends RelationThunks, Relation extends HasMany> = {
+declare type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany> = {
     params: Relation['options'] extends {
         primaryKey: string;
     } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
@@ -37,7 +38,7 @@ interface HasOne extends RelationThunkBase {
     returns: 'one';
     options: HasOneRelation['options'];
 }
-declare type HasOneInfo<T extends Model, Relations extends RelationThunks, Relation extends HasOne> = {
+declare type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne> = {
     params: Relation['options'] extends {
         primaryKey: string;
     } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
@@ -56,27 +57,27 @@ declare function transaction<T extends {
     $queryBuilder: Db;
 }, Result>(this: T, fn: (db: T) => Promise<Result>): Promise<Result>;
 
-declare type OrchidORM<T extends ModelClasses> = {
-    [K in keyof T]: DbModel<T[K]>;
+declare type OrchidORM<T extends TableClasses> = {
+    [K in keyof T]: DbTable<T[K]>;
 } & {
     $transaction: typeof transaction;
     $adapter: Adapter;
     $queryBuilder: Db;
     $close(): Promise<void>;
 };
-declare const orchidORM: <T extends ModelClasses>({ log, logger, autoPreparedStatements, noPrimaryKey, ...options }: (Omit<AdapterOptions, "log"> | {
+declare const orchidORM: <T extends TableClasses>({ log, logger, autoPreparedStatements, noPrimaryKey, ...options }: (Omit<AdapterOptions, "log"> | {
     adapter: Adapter;
 }) & QueryLogOptions & {
     autoPreparedStatements?: boolean | undefined;
     noPrimaryKey?: NoPrimaryKeyOption | undefined;
-}, models: T) => OrchidORM<T>;
+}, tables: T) => OrchidORM<T>;
 
 interface HasAndBelongsToMany extends RelationThunkBase {
     type: 'hasAndBelongsToMany';
     returns: 'many';
     options: HasAndBelongsToManyRelation['options'];
 }
-declare type HasAndBelongsToManyInfo<T extends Model, Relation extends HasAndBelongsToMany> = {
+declare type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany> = {
     params: Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']>;
     populate: never;
     chainedCreate: true;
@@ -86,16 +87,16 @@ declare type HasAndBelongsToManyInfo<T extends Model, Relation extends HasAndBel
 interface RelationThunkBase {
     type: string;
     returns: 'one' | 'many';
-    fn(): ModelClass;
+    fn(): TableClass;
     options: BaseRelation['options'];
 }
 declare type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
 declare type RelationThunks = Record<string, RelationThunk>;
-declare type Relation<T extends Model, Relations extends RelationThunks, K extends keyof Relations, M extends Query = DbModel<ReturnType<Relations[K]['fn']>>, Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>> = {
+declare type Relation<T extends Table, Relations extends RelationThunks, K extends keyof Relations, 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'];
@@ -105,45 +106,45 @@ declare type Relation<T extends Model, Relations extends RelationThunks, K exten
     primaryKey: string;
     options: Relations[K]['options'];
 };
-declare type RelationScopeOrModel<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbModel<ReturnType<Relation['fn']>>;
-declare type RelationInfo<T extends Model = Model, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk> = Relation extends BelongsTo ? BelongsToInfo<T, Relation> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation> : never;
-declare type MapRelation<T extends Model, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrModel<Relation>, Info extends {
+declare type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbTable<ReturnType<Relation['fn']>>;
+declare type RelationInfo<T extends Table = Table, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk> = Relation extends BelongsTo ? BelongsToInfo<T, Relation> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation> : never;
+declare type MapRelation<T extends Table, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrTable<Relation>, Info extends {
     params: Record<string, unknown>;
     populate: string;
     chainedCreate: boolean;
     chainedDelete: boolean;
 } = RelationInfo<T, Relations, Relation>> = RelationQuery<RelationName, Info['params'], Info['populate'], Relation['returns'] extends 'one' ? Relation['options']['required'] extends true ? SetQueryReturnsOne<RelatedQuery> : SetQueryReturnsOneOptional<RelatedQuery> : SetQueryReturnsAll<RelatedQuery>, Relation['options']['required'] extends boolean ? Relation['options']['required'] : false, Info['chainedCreate'], Info['chainedDelete']>;
-declare type MapRelations<T extends Model> = 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
+declare type MapRelations<T extends Table> = 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
     [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
 } : EmptyObject : EmptyObject;
 
-declare type ModelClass<T extends Model = Model> = new () => T;
-declare type ModelClasses = Record<string, ModelClass>;
-declare type ModelToDb<T extends Model> = Db<T['table'], T['columns']['shape'], 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
+declare type TableClass<T extends Table = Table> = new () => T;
+declare type TableClasses = Record<string, TableClass>;
+declare 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<ModelClasses>;
+    db: OrchidORM<TableClasses>;
 };
-declare type DbModel<T extends ModelClass> = ModelToDb<InstanceType<T>> & Omit<MapRelations<InstanceType<T>>, keyof Query>;
-declare type ModelConfig = {
+declare type DbTable<T extends TableClass> = TableToDb<InstanceType<T>> & Omit<MapRelations<InstanceType<T>>, keyof Query>;
+declare type TableConfig = {
     shape: ColumnsShape;
     type: unknown;
 };
-declare type ScopeFn<Related extends ModelClass, Scope extends Query> = (q: DbModel<Related>) => Scope;
-declare type Model = {
+declare type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<Related>) => Scope;
+declare type Table = {
     table: string;
-    columns: ModelConfig;
+    columns: TableConfig;
     schema?: string;
     columnTypes: ColumnTypesBase;
     noPrimaryKey?: boolean;
 };
-declare const createModel: <CT extends ColumnTypesBase>(options: {
+declare const createBaseTable: <CT extends ColumnTypesBase>(options: {
     columnTypes: CT;
 }) => {
     new (): {
         table: string;
-        columns: ModelConfig;
+        columns: TableConfig;
         schema?: string | undefined;
         columnTypes: CT;
         noPrimaryKey?: boolean | undefined;
@@ -151,7 +152,7 @@ declare const createModel: <CT extends ColumnTypesBase>(options: {
             shape: T;
             type: ColumnShapeOutput<T>;
         };
-        belongsTo<Self extends any, Related extends ModelClass<Model>, Scope extends Query, Options extends {
+        belongsTo<Self extends any, Related extends TableClass<Table>, Scope extends Query, Options extends {
             primaryKey: keyof InstanceType<Related>["columns"]["shape"];
             foreignKey: keyof Self["columns"]["shape"];
             scope?: ScopeFn<Related, Scope> | undefined;
@@ -162,7 +163,7 @@ declare const createModel: <CT extends ColumnTypesBase>(options: {
             fn: () => Related;
             options: Options;
         };
-        hasOne<Self_1 extends any, Related_1 extends ModelClass<Model>, Scope_1 extends Query, Through extends string, Source extends string, Options_1 extends ({
+        hasOne<Self_1 extends any, Related_1 extends TableClass<Table>, Scope_1 extends Query, Through extends string, Source extends string, Options_1 extends ({
             primaryKey: keyof Self_1["columns"]["shape"];
             foreignKey: keyof InstanceType<Related_1>["columns"]["shape"];
         } | {
@@ -177,7 +178,7 @@ declare const createModel: <CT extends ColumnTypesBase>(options: {
             fn: () => Related_1;
             options: Options_1;
         };
-        hasMany<Self_2 extends any, Related_2 extends ModelClass<Model>, Scope_2 extends Query, Through_1 extends string, Source_1 extends string, Options_2 extends ({
+        hasMany<Self_2 extends any, Related_2 extends TableClass<Table>, Scope_2 extends Query, Through_1 extends string, Source_1 extends string, Options_2 extends ({
             primaryKey: keyof Self_2["columns"]["shape"];
             foreignKey: keyof InstanceType<Related_2>["columns"]["shape"];
         } | {
@@ -192,7 +193,7 @@ declare const createModel: <CT extends ColumnTypesBase>(options: {
             fn: () => Related_2;
             options: Options_2;
         };
-        hasAndBelongsToMany<Self_3 extends any, Related_3 extends ModelClass<Model>, Scope_3 extends Query, Options_3 extends {
+        hasAndBelongsToMany<Self_3 extends any, Related_3 extends TableClass<Table>, Scope_3 extends Query, Options_3 extends {
             primaryKey: keyof Self_3["columns"]["shape"];
             associationPrimaryKey: keyof InstanceType<Related_3>["columns"]["shape"];
             foreignKey: string;
@@ -226,6 +227,12 @@ declare type Repo<T extends Query, Methods extends MethodsBase<T>, Mapped = MapM
     table: T['table'];
     shape: T['shape'];
 }>(q: Q) => Q & Mapped) & T & Mapped;
-declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(model: T, methods: Methods) => Repo<T, Methods, MapMethods<T, Methods>>;
+declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(table: T, methods: Methods) => Repo<T, Methods, MapMethods<T, Methods>>;
 
-export { DbModel, MapMethods, MapQueryMethods, MethodsBase, Model, ModelClass, ModelClasses, ModelToDb, OrchidORM, QueryMethods, Repo, createModel, createRepo, orchidORM };
+declare type AppCodeUpdaterConfig = {
+    tablePath(tableName: string): string;
+    mainFilePath: string;
+};
+declare const appCodeUpdater: () => AppCodeUpdater;
+
+export { AppCodeUpdaterConfig, DbTable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, QueryMethods, Repo, Table, TableClass, TableClasses, TableToDb, appCodeUpdater, createBaseTable, createRepo, orchidORM };

package/dist/index.esm.js

@@ -1,7 +1,7 @@
 import { getColumnTypes, addQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, getQueryAs, toSqlCacheKey, NotFoundError, relationQueryKey, Db, Adapter, anyShape, columnTypes, getClonedQueryData } from 'pqb';
 
-const createModel = (options) => {
-  return class Model {
+const createBaseTable = (options) => {
+  return class BaseTable {
     constructor() {
       this.setColumns = (fn) => {
         const shape = getColumnTypes(options.columnTypes, fn);
@@ -239,11 +239,11 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
   };
 };
 
-const getThroughRelation = (model, through) => {
-  return model.relations[through];
+const getThroughRelation = (table, through) => {
+  return table.relations[through];
 };
 const getSourceRelation = (throughRelation, source) => {
-  return throughRelation.model.relations[source];
+  return throughRelation.table.relations[source];
 };
 const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKey, nestedInsert) => {
   const value = item[key];
@@ -341,7 +341,7 @@ class HasOneVirtualColumn extends VirtualColumn {
     );
   }
 }
-const makeHasOneMethod = (model, relation, relationName, query) => {
+const makeHasOneMethod = (table, relation, relationName, query) => {
   if (relation.options.required) {
     query._take();
   } else {
@@ -349,14 +349,14 @@ const makeHasOneMethod = (model, relation, relationName, query) => {
   }
   if ("through" in relation.options) {
     const { through, source } = relation.options;
-    const throughRelation = getThroughRelation(model, through);
+    const throughRelation = getThroughRelation(table, through);
     const sourceRelation = getSourceRelation(throughRelation, source);
     const sourceQuery = sourceRelation.joinQuery(throughRelation.query, sourceRelation.query).as(relationName);
     const whereExistsCallback = () => sourceQuery;
     return {
       returns: "one",
       method: (params) => {
-        const throughQuery = model[through](params);
+        const throughQuery = table[through](params);
         return query.whereExists(
           throughQuery,
           whereExistsCallback
@@ -538,10 +538,10 @@ class HasManyVirtualColumn extends VirtualColumn {
     );
   }
 }
-const makeHasManyMethod = (model, relation, relationName, query) => {
+const makeHasManyMethod = (table, relation, relationName, query) => {
   if ("through" in relation.options) {
     const { through, source } = relation.options;
-    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(
@@ -552,7 +552,7 @@ const makeHasManyMethod = (model, relation, relationName, query) => {
     return {
       returns: "many",
       method: (params) => {
-        const throughQuery = model[through](params);
+        const throughQuery = table[through](params);
         return query.whereExists(
           throughQuery,
           whereExistsCallback
@@ -784,7 +784,7 @@ class HasAndBelongsToManyVirtualColumn extends VirtualColumn {
     );
   }
 }
-const makeHasAndBelongsToManyMethod = (model, qb, relation, relationName, query) => {
+const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query) => {
   const {
     primaryKey: pk,
     foreignKey: fk,
@@ -795,14 +795,14 @@ const makeHasAndBelongsToManyMethod = (model, qb, relation, relationName, query)
   const foreignKeyFull = `${joinTable}.${fk}`;
   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 = __spreadValues$2({}, subQuery.query);
   const state = {
     relatedTableQuery: query,
@@ -1052,38 +1052,40 @@ const nestedUpdate = (state) => {
   };
 };
 
-const applyRelations = (qb, models, result) => {
-  const modelsEntries = Object.entries(models);
+const applyRelations = (qb, tables, result) => {
+  const tableEntries = Object.entries(tables);
   const delayedRelations = /* @__PURE__ */ new Map();
-  for (const modelName in models) {
-    const model = models[modelName];
-    if (!("relations" in model) || typeof model.relations !== "object")
+  for (const name in tables) {
+    const table = tables[name];
+    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 = {
         relationName,
         relation,
-        dbModel,
-        otherDbModel
+        dbTable,
+        otherDbTable
       };
       const options = relation.options;
       if (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;
         }
         const sourceRelation = getSourceRelation(
@@ -1093,7 +1095,7 @@ const applyRelations = (qb, models, result) => {
         if (!sourceRelation) {
           delayRelation(
             delayedRelations,
-            throughRelation.model,
+            throughRelation.table,
             options.source,
             data
           );
@@ -1108,42 +1110,42 @@ const applyRelations = (qb, models, result) => {
     for (const key in value) {
       for (const item of value[key]) {
         const { relation } = item;
-        if (item.dbModel.relations[item.relationName])
+        if (item.dbTable.relations[item.relationName])
           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;
-        const throughRel = model.relations[through];
+        const throughRel = table.relations[through];
         if (through && !throughRel) {
           message += `: cannot find \`${through}\` relation required by the \`through\` option`;
-        } else if (source && throughRel && !throughRel.model.relations[source]) {
-          message += `: cannot find \`${source}\` relation in \`${throughRel.model.definedAs}\` required by the \`source\` option`;
+        } else if (source && throughRel && !throughRel.table.relations[source]) {
+          message += `: cannot find \`${source}\` relation in \`${throughRel.table.definedAs}\` required by the \`source\` option`;
         }
         throw new Error(message);
       }
     }
   }
 };
-const delayRelation = (delayedRelations, model, relationName, data) => {
-  let modelRelations = delayedRelations.get(model);
-  if (!modelRelations) {
-    modelRelations = {};
-    delayedRelations.set(model, modelRelations);
+const delayRelation = (delayedRelations, table, relationName, data) => {
+  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, { relationName, relation, dbModel, otherDbModel }, delayedRelations) => {
+const applyRelation = (qb, { relationName, relation, dbTable, otherDbTable }, delayedRelations) => {
   var _a;
-  const query = (relation.options.scope ? relation.options.scope(otherDbModel) : otherDbModel).as(relationName);
+  const query = (relation.options.scope ? relation.options.scope(otherDbTable) : otherDbTable).as(relationName);
   const definedAs = query.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`
     );
   }
   const { type } = relation;
@@ -1151,12 +1153,12 @@ const applyRelation = (qb, { relationName, relation, dbModel, otherDbModel }, de
   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,
@@ -1169,38 +1171,38 @@ const applyRelation = (qb, { relationName, relation, dbModel, otherDbModel }, de
     query._take();
   }
   if (data.virtualColumn) {
-    dbModel.shape[relationName] = data.virtualColumn;
+    dbTable.shape[relationName] = data.virtualColumn;
   }
-  makeRelationQuery(dbModel, definedAs, relationName, data);
-  dbModel.relations[relationName] = {
+  makeRelationQuery(dbTable, definedAs, relationName, data);
+  dbTable.relations[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)
+  const tableRelations = delayedRelations.get(dbTable);
+  if (!tableRelations)
     return;
-  (_a = modelRelations[relationName]) == null ? void 0 : _a.forEach((data2) => {
+  (_a = tableRelations[relationName]) == null ? void 0 : _a.forEach((data2) => {
     applyRelation(qb, data2, delayedRelations);
   });
 };
-const makeRelationQuery = (model, definedAs, relationName, data) => {
-  Object.defineProperty(model, relationName, {
+const makeRelationQuery = (table, definedAs, relationName, data) => {
+  Object.defineProperty(table, relationName, {
     get() {
       var _a;
-      const toModel = this.db[definedAs].as(relationName);
+      const toTable = this.db[definedAs].as(relationName);
       if (data.returns === "one") {
-        toModel._take();
+        toTable._take();
       }
-      const query = this.isSubQuery ? toModel : toModel._whereExists(data.reverseJoin(this, toModel), (q) => q);
+      const query = this.isSubQuery ? toTable : toTable._whereExists(data.reverseJoin(this, toTable), (q) => q);
       query.query[relationQueryKey] = {
         relationName,
         sourceQuery: this,
-        relationQuery: toModel,
+        relationQuery: toTable,
         joinQuery: data.joinQuery
       };
       const setQuery = (_a = data.modifyRelatedQuery) == null ? void 0 : _a.call(data, query);
@@ -1223,10 +1225,10 @@ function transaction(fn) {
     for (const key in this) {
       const value = this[key];
       if (value instanceof Db) {
-        const model = value.transacting(q);
-        model.__model = model;
-        model.db = orm;
-        orm[key] = model;
+        const table = value.transacting(q);
+        table.__table = table;
+        table.db = orm;
+        orm[key] = table;
       } else {
         orm[key] = value;
       }
@@ -1266,7 +1268,7 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
-const orchidORM = (_a, models) => {
+const orchidORM = (_a, tables) => {
   var _b = _a, {
     log,
     logger,
@@ -1300,31 +1302,31 @@ const orchidORM = (_a, models) => {
     $queryBuilder: qb,
     $close: () => adapter.close()
   };
-  const modelInstances = {};
-  for (const key in models) {
+  const tableInstances = {};
+  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 options2 = __spreadProps(__spreadValues$1({}, commonOptions), {
-      schema: model.schema
+      schema: table.schema
     });
-    if (model.noPrimaryKey)
+    if (table.noPrimaryKey)
       options2.noPrimaryKey = "ignore";
-    const dbModel = new Db(
+    const dbTable = new Db(
       adapter,
       qb,
-      model.table,
-      model.columns.shape,
-      model.columnTypes,
+      table.table,
+      table.columns.shape,
+      table.columnTypes,
       options2
     );
-    dbModel.definedAs = key;
-    dbModel.db = result;
-    result[key] = dbModel;
+    dbTable.definedAs = key;
+    dbTable.db = result;
+    result[key] = dbTable;
   }
-  applyRelations(qb, modelInstances, result);
+  applyRelations(qb, tableInstances, result);
   return result;
 };
 
@@ -1344,26 +1346,26 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const createRepo = (model, methods) => {
+const createRepo = (table, methods) => {
   const queryMethods = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, methods.queryMethods), methods.queryOneMethods), methods.queryWithWhereMethods), methods.queryOneWithWhereMethods);
   const plainMethods = methods.methods;
   const repo = (q2) => {
-    const proto = Object.create(q2.__model);
-    proto.__model = proto;
+    const proto = Object.create(q2.__table);
+    proto.__table = proto;
     const result = Object.create(proto);
     result.query = getClonedQueryData(q2.query);
     if (plainMethods) {
-      Object.assign(proto.__model, plainMethods);
+      Object.assign(proto.__table, plainMethods);
     }
     for (const key in queryMethods) {
       const method = queryMethods[key];
-      proto.__model[key] = function(...args) {
+      proto.__table[key] = function(...args) {
         return method(this, ...args);
       };
     }
     return result;
   };
-  const q = repo(model);
+  const q = repo(table);
   return new Proxy(repo, {
     get(_, key) {
       return q[key];
@@ -1371,5 +1373,5 @@ const createRepo = (model, methods) => {
   });
 };
 
-export { createModel, createRepo, orchidORM };
+export { createBaseTable, createRepo, orchidORM };
 //# sourceMappingURL=index.esm.js.map