pqb 0.7.13 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pqb",
-  "version": "0.7.13",
+  "version": "0.8.0",
   "description": "Postgres query builder",
   "homepage": "https://orchid-orm.netlify.app/guide/query-builder-setup.html",
   "repository": {

package/src/columnSchema/columnType.test.ts

@@ -34,7 +34,7 @@ describe('column base', () => {
       expect(column.hidden().isHidden).toBe(true);
     });
 
-    test('model with hidden column should omit from select it by default', () => {
+    test('table with hidden column should omit from select it by default', () => {
       const User = db('user', (t) => ({
         id: t.serial().primaryKey(),
         name: t.text(),
@@ -53,7 +53,7 @@ describe('column base', () => {
       );
     });
 
-    test('model with hidden column still allows to select it', () => {
+    test('table with hidden column still allows to select it', () => {
       const User = db('user', (t) => ({
         id: t.serial().primaryKey(),
         name: t.text(),

package/src/columnSchema/columnType.ts

@@ -100,17 +100,17 @@ export type IndexOptions = {
 
 export type SingleColumnIndexOptions = IndexColumnOptions & IndexOptions;
 
-export type ForeignKeyModel = new () => {
+export type ForeignKeyTable = new () => {
   table: string;
 };
 
-export type ForeignKeyModelWithColumns = new () => {
+export type ForeignKeyTableWithColumns = new () => {
   table: string;
   columns: { shape: ColumnsShape };
 };
 
-export type ColumnNameOfModel<Model extends ForeignKeyModelWithColumns> =
-  StringKey<keyof InstanceType<Model>['columns']['shape']>;
+export type ColumnNameOfTable<Table extends ForeignKeyTableWithColumns> =
+  StringKey<keyof InstanceType<Table>['columns']['shape']>;
 
 const addColumnData = <T extends ColumnType, K extends keyof ColumnData>(
   q: T,
@@ -157,15 +157,15 @@ export abstract class ColumnType<
 
   foreignKey<
     T extends ColumnType,
-    Model extends ForeignKeyModelWithColumns,
-    Column extends ColumnNameOfModel<Model>,
+    Table extends ForeignKeyTableWithColumns,
+    Column extends ColumnNameOfTable<Table>,
   >(
     this: T,
-    fn: () => Model,
+    fn: () => Table,
     column: Column,
     options?: ForeignKeyOptions,
   ): Omit<T, 'foreignKeyData'> & {
-    foreignKeyData: ForeignKey<InstanceType<Model>['table'], [Column]>;
+    foreignKeyData: ForeignKey<InstanceType<Table>['table'], [Column]>;
   };
   foreignKey<T extends ColumnType, Table extends string, Column extends string>(
     this: T,
@@ -176,7 +176,7 @@ export abstract class ColumnType<
     foreignKeyData: ForeignKey<Table, [Column]>;
   };
   foreignKey(
-    fnOrTable: (() => ForeignKeyModel) | string,
+    fnOrTable: (() => ForeignKeyTable) | string,
     column: string,
     options: ForeignKeyOptions = {},
   ) {

package/src/columnSchema/columnTypes.ts

@@ -47,14 +47,14 @@ import { JSONColumn, JSONTextColumn, JSONTypes } from './json';
 import { JSONTypeAny } from './json/typeBase';
 import { ArrayColumn } from './array';
 import {
-  ColumnNameOfModel,
+  ColumnNameOfTable,
   ColumnType,
   ColumnTypesBase,
-  ForeignKeyModel,
+  ForeignKeyTable,
   IndexColumnOptions,
   IndexOptions,
   ForeignKeyOptions,
-  ForeignKeyModelWithColumns,
+  ForeignKeyTableWithColumns,
 } from './columnType';
 import { emptyObject, EmptyObject, MaybeArray, toArray } from '../utils';
 import { ColumnsShape } from './columnsSchema';
@@ -63,15 +63,29 @@ import { timestamps } from './timestamps';
 export type ColumnTypes = typeof columnTypes;
 
 export type TableData = {
-  primaryKey?: { columns: string[]; options?: { name?: string } };
-  indexes: { columns: IndexColumnOptions[]; options: IndexOptions }[];
-  foreignKeys: {
+  primaryKey?: TableData.PrimaryKey;
+  indexes: TableData.Index[];
+  foreignKeys: TableData.ForeignKey[];
+};
+
+export namespace TableData {
+  export type PrimaryKey = {
+    columns: string[];
+    options?: { name?: string };
+  };
+
+  export type Index = {
+    columns: IndexColumnOptions[];
+    options: IndexOptions;
+  };
+
+  export type ForeignKey = {
     columns: string[];
-    fnOrTable: (() => ForeignKeyModel) | string;
+    fnOrTable: (() => ForeignKeyTable) | string;
     foreignColumns: string[];
     options: ForeignKeyOptions;
-  }[];
-};
+  };
+}
 
 export const newTableData = (): TableData => ({
   indexes: [],
@@ -221,11 +235,11 @@ export const columnTypes = {
 };
 
 function foreignKey<
-  Model extends ForeignKeyModelWithColumns,
-  Columns extends [ColumnNameOfModel<Model>, ...ColumnNameOfModel<Model>[]],
+  Table extends ForeignKeyTableWithColumns,
+  Columns extends [ColumnNameOfTable<Table>, ...ColumnNameOfTable<Table>[]],
 >(
   columns: string[],
-  fn: () => Model,
+  fn: () => Table,
   foreignColumns: Columns,
   options?: ForeignKeyOptions,
 ): EmptyObject;
@@ -240,7 +254,7 @@ function foreignKey<
 ): EmptyObject;
 function foreignKey(
   columns: string[],
-  fnOrTable: (() => ForeignKeyModel) | string,
+  fnOrTable: (() => ForeignKeyTable) | string,
   foreignColumns: string[],
   options: ForeignKeyOptions = {},
 ) {

package/src/columnSchema/timestamps.test.ts

@@ -3,13 +3,13 @@ import { db, expectSql, now, useTestDatabase } from '../test-utils/test-utils';
 describe('timestamps', () => {
   useTestDatabase();
 
-  const model = db('user', (t) => ({
+  const table = db('user', (t) => ({
     name: t.text().primaryKey(),
     ...t.timestamps(),
   }));
 
   it('should update updatedAt column when updating', async () => {
-    const query = model.where().update({});
+    const query = table.where().update({});
     await query;
 
     expectSql(
@@ -22,7 +22,7 @@ describe('timestamps', () => {
   });
 
   it('should not update updatedAt column when updating it via object', async () => {
-    const query = model.where().update({ updatedAt: now });
+    const query = table.where().update({ updatedAt: now });
     await query;
 
     expectSql(
@@ -36,7 +36,7 @@ describe('timestamps', () => {
   });
 
   it('should update updatedAt when updating with raw sql', async () => {
-    const query = model
+    const query = table
       .where()
       .updateRaw(db.raw('name = $name', { name: 'name' }));
 
@@ -53,7 +53,7 @@ describe('timestamps', () => {
   });
 
   it('should update updatedAt when updating with raw sql which has updatedAt somewhere but not in set', async () => {
-    const query = model.where().updateRaw(db.raw('"createdAt" = "updatedAt"'));
+    const query = table.where().updateRaw(db.raw('"createdAt" = "updatedAt"'));
     await query;
 
     expectSql(
@@ -66,7 +66,7 @@ describe('timestamps', () => {
   });
 
   it('should not update updatedAt column when updating with raw sql which contains `updatedAt = `', async () => {
-    const query = model
+    const query = table
       .where()
       .updateRaw(db.raw('"updatedAt" = $time', { time: now }));
 

package/src/db.ts

@@ -132,7 +132,7 @@ export class Db<
     public columnTypes: CT,
     options: DbTableOptions,
   ) {
-    this.__model = this as Query;
+    this.__table = this as Query;
 
     const logger = options.logger || console;
     this.query = {

package/src/query.ts

@@ -38,7 +38,7 @@ export type QueryBase = {
   clone(): QueryBase;
   selectable: SelectableBase;
   shape: ColumnsShape;
-  __model: Query;
+  __table: Query;
   relations: RelationsBase;
   withData: WithDataBase;
 };

package/src/queryMethods/create.ts

@@ -72,14 +72,14 @@ type CreateBelongsToData<
           }
         | {
             create?: never;
-            connect: WhereArg<Rel['model']>;
+            connect: WhereArg<Rel['table']>;
             connectOrCreate?: never;
           }
         | {
             create?: never;
             connect?: never;
             connectOrCreate: {
-              where: WhereArg<Rel['model']>;
+              where: WhereArg<Rel['table']>;
               create: CreateData<Rel['nestedCreateQuery']>;
             };
           };
@@ -101,14 +101,14 @@ type CreateHasOneData<
           }
         | {
             create?: never;
-            connect: WhereArg<Rel['model']>;
+            connect: WhereArg<Rel['table']>;
             connectOrCreate?: never;
           }
         | {
             create?: never;
             connect?: never;
             connectOrCreate: {
-              where?: WhereArg<Rel['model']>;
+              where?: WhereArg<Rel['table']>;
               create?: CreateData<Rel['nestedCreateQuery']>;
             };
           };
@@ -124,9 +124,9 @@ type CreateHasManyData<
   : {
       [K in Key]?: {
         create?: CreateData<Rel['nestedCreateQuery']>[];
-        connect?: WhereArg<Rel['model']>[];
+        connect?: WhereArg<Rel['table']>[];
         connectOrCreate?: {
-          where: WhereArg<Rel['model']>;
+          where: WhereArg<Rel['table']>;
           create: CreateData<Rel['nestedCreateQuery']>;
         }[];
       };

package/src/queryMethods/for.ts

@@ -15,10 +15,10 @@ const forQueryBuilder = <T extends Query>(
   tableNames?: string[] | RawExpression,
 ) => {
   (q.query as SelectQueryData).for = { type, tableNames };
-  q.__model = Object.create(q.__model);
-  q.__model.__model = q.__model;
+  q.__table = Object.create(q.__table);
+  q.__table.__table = q.__table;
 
-  Object.assign(q.__model, {
+  Object.assign(q.__table, {
     noWait<T extends ForQueryBuilder<Query>>(this: T): T {
       return this.clone()._noWait();
     },

package/src/queryMethods/having.ts

@@ -29,7 +29,7 @@ export type HavingArg<T extends Query = Query> =
   | RawExpression;
 
 const processHavingArg = <T extends Query>(arg: HavingArg<T>): HavingItem => {
-  if ('__model' in arg || isRaw(arg)) {
+  if ('__table' in arg || isRaw(arg)) {
     return arg;
   } else {
     const processed = { ...arg } as Record<

package/src/queryMethods/join.ts

@@ -78,7 +78,7 @@ type JoinResult<
     ? A
     : T['relations'] extends Record<string, Relation>
     ? A extends keyof T['relations']
-      ? T['relations'][A]['model']
+      ? T['relations'][A]['table']
       : A extends keyof T['withData']
       ? T['withData'][A] extends WithDataItem
         ? {
@@ -116,7 +116,7 @@ export type JoinCallback<
               };
             };
             shape: T['withData'][Arg]['shape'];
-            __model: Query;
+            __table: Query;
             relations: RelationsBase;
             withData: WithDataBase;
           }
@@ -125,7 +125,7 @@ export type JoinCallback<
       ? Arg
       : T['relations'] extends Record<string, Relation>
       ? Arg extends keyof T['relations']
-        ? T['relations'][Arg]['model']
+        ? T['relations'][Arg]['table']
         : never
       : never
   >,
@@ -140,7 +140,7 @@ type JoinCallbackResult<
     ? Arg
     : T['relations'] extends Record<string, Relation>
     ? Arg extends keyof T['relations']
-      ? T['relations'][Arg]['model']
+      ? T['relations'][Arg]['table']
       : Arg extends keyof T['withData']
       ? T['withData'][Arg] extends WithDataItem
         ? {

package/src/queryMethods/json.ts

@@ -53,7 +53,7 @@ export class Json {
   _json<T extends Query>(
     this: T,
   ): SetQueryReturnsValueOptional<T, StringColumn> {
-    const q = this._wrap(this.__model.clone()) as T;
+    const q = this._wrap(this.__table.clone()) as T;
     q._getOptional(
       raw(
         queryTypeWithLimitOne[this.query.returnType]

package/src/queryMethods/queryMethods.ts

@@ -104,7 +104,7 @@ export interface QueryMethods
 
 export class QueryMethods {
   windows!: EmptyObject;
-  __model!: Query;
+  __table!: Query;
 
   all<T extends Query>(this: T): SetQueryReturnsAll<T> {
     return this.clone()._all();
@@ -169,7 +169,7 @@ export class QueryMethods {
   }
 
   clone<T extends QueryBase>(this: T): T {
-    const cloned = Object.create(this.__model);
+    const cloned = Object.create(this.__table);
     cloned.query = getClonedQueryData(this.query);
     return cloned;
   }

package/src/queryMethods/select.ts

@@ -50,11 +50,11 @@ type SelectResult<
       : T['relations'] extends Record<string, Relation>
       ? Arg extends keyof T['relations']
         ? T['relations'][Arg]['returns'] extends 'many'
-          ? ArrayOfColumnsObjects<T['relations'][Arg]['model']['result']>
+          ? ArrayOfColumnsObjects<T['relations'][Arg]['table']['result']>
           : T['relations'][Arg]['options']['required'] extends true
-          ? ColumnsObject<T['relations'][Arg]['model']['result']>
+          ? ColumnsObject<T['relations'][Arg]['table']['result']>
           : NullableColumn<
-              ColumnsObject<T['relations'][Arg]['model']['result']>
+              ColumnsObject<T['relations'][Arg]['table']['result']>
             >
         : never
       : never;

package/src/queryMethods/update.ts

@@ -36,9 +36,9 @@ export type UpdateData<T extends Query> = {
 
 type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> =
   | { disconnect: boolean }
-  | { set: WhereArg<Rel['model']> }
+  | { set: WhereArg<Rel['table']> }
   | { delete: boolean }
-  | { update: UpdateData<Rel['model']> }
+  | { update: UpdateData<Rel['table']> }
   | {
       create: CreateData<Rel['nestedCreateQuery']>;
     }
@@ -46,7 +46,7 @@ type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> =
       ? never
       : {
           upsert: {
-            update: UpdateData<Rel['model']>;
+            update: UpdateData<Rel['table']>;
             create: CreateData<Rel['nestedCreateQuery']>;
           };
         });
@@ -54,14 +54,14 @@ type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> =
 type UpdateHasOneData<T extends Query, Rel extends HasOneRelation> =
   | { disconnect: boolean }
   | { delete: boolean }
-  | { update: UpdateData<Rel['model']> }
+  | { update: UpdateData<Rel['table']> }
   | (QueryReturnsAll<T['returnType']> extends true
       ? never
       :
-          | { set: WhereArg<Rel['model']> }
+          | { set: WhereArg<Rel['table']> }
           | {
               upsert: {
-                update: UpdateData<Rel['model']>;
+                update: UpdateData<Rel['table']>;
                 create: CreateData<Rel['nestedCreateQuery']>;
               };
             }
@@ -70,26 +70,26 @@ type UpdateHasOneData<T extends Query, Rel extends HasOneRelation> =
             });
 
 type UpdateHasManyData<T extends Query, Rel extends HasManyRelation> = {
-  disconnect?: MaybeArray<WhereArg<Rel['model']>>;
-  delete?: MaybeArray<WhereArg<Rel['model']>>;
+  disconnect?: MaybeArray<WhereArg<Rel['table']>>;
+  delete?: MaybeArray<WhereArg<Rel['table']>>;
   update?: {
-    where: MaybeArray<WhereArg<Rel['model']>>;
-    data: UpdateData<Rel['model']>;
+    where: MaybeArray<WhereArg<Rel['table']>>;
+    data: UpdateData<Rel['table']>;
   };
 } & (QueryReturnsAll<T['returnType']> extends true
   ? EmptyObject
   : {
-      set?: MaybeArray<WhereArg<Rel['model']>>;
+      set?: MaybeArray<WhereArg<Rel['table']>>;
       create?: CreateData<Rel['nestedCreateQuery']>[];
     });
 
 type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
-  disconnect?: MaybeArray<WhereArg<Rel['model']>>;
-  set?: MaybeArray<WhereArg<Rel['model']>>;
-  delete?: MaybeArray<WhereArg<Rel['model']>>;
+  disconnect?: MaybeArray<WhereArg<Rel['table']>>;
+  set?: MaybeArray<WhereArg<Rel['table']>>;
+  delete?: MaybeArray<WhereArg<Rel['table']>>;
   update?: {
-    where: MaybeArray<WhereArg<Rel['model']>>;
-    data: UpdateData<Rel['model']>;
+    where: MaybeArray<WhereArg<Rel['table']>>;
+    data: UpdateData<Rel['table']>;
   };
   create?: CreateData<Rel['nestedCreateQuery']>[];
 };
@@ -213,7 +213,7 @@ export class Update {
         if (ctx.updateLater) {
           await Promise.all(ctx.updateLaterPromises as Promise<void>[]);
 
-          const t = this.__model.clone().transacting(q);
+          const t = this.__table.clone().transacting(q);
           const keys = this.primaryKeys;
           (
             t._whereIn as unknown as (

package/src/queryMethods/where.test.ts

@@ -1563,7 +1563,7 @@ export const testJoin = (
       };
     };
 
-    Object.assign(withRelation.__model, {
+    Object.assign(withRelation.__table, {
       relations: {
         message: {
           key: 'message',

package/src/queryMethods/where.ts

@@ -143,7 +143,7 @@ export abstract class Where implements QueryBase {
   abstract shape: ColumnsShape;
   abstract relations: RelationsBase;
   abstract withData: WithDataBase;
-  abstract __model: Query;
+  abstract __table: Query;
 
   query = {} as QueryData;
   table?: string;
@@ -437,21 +437,21 @@ export class WhereQueryBuilder<Q extends QueryBase = QueryBase>
   selectable!: Q['selectable'];
   shape: Q['shape'];
   relations!: Q['relations'];
-  __model: Query;
+  __table: Query;
   withData = {};
 
   constructor(q: QueryBase | string, shape: ColumnsShape) {
     super();
     this.table = typeof q === 'object' ? q.table : q;
     this.shape = shape;
-    this.__model = this as unknown as Query;
+    this.__table = this as unknown as Query;
     if (typeof q === 'object' && q.query.as) {
       this.query.as = q.query.as;
     }
   }
 
   clone<T extends this>(this: T): T {
-    const cloned = Object.create(this.__model);
+    const cloned = Object.create(this.__table);
     cloned.query = getClonedQueryData(this.query);
     return cloned as unknown as T;
   }

package/src/relations.ts

@@ -5,7 +5,7 @@ import { EmptyObject } from './utils';
 export type BaseRelation = {
   type: string;
   key: string;
-  model: QueryWithTable;
+  table: QueryWithTable;
   query: QueryWithTable;
   joinQuery(fromQuery: QueryBase, toQuery: Query): Query;
   nestedCreateQuery: Query;

package/src/sql/aggregate.ts

@@ -9,7 +9,7 @@ import { ToSqlCtx } from './toSql';
 
 export const aggregateToSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   item: AggregateItem,
   quotedAs?: string,
 ) => {
@@ -58,7 +58,7 @@ export const aggregateToSql = (
   if (options.filter || options.filterOr) {
     const whereSql = whereToSql(
       ctx,
-      model,
+      table,
       {
         and: options.filter ? [options.filter] : undefined,
         or: options.filterOr?.map((item) => [item]),

package/src/sql/copy.ts

@@ -7,7 +7,7 @@ import { pushWhereStatementSql } from './where';
 
 export const pushCopySql = (
   ctx: ToSqlCtx,
-  model: Query,
+  table: Query,
   query: CopyQueryData,
   quotedAs?: string,
 ) => {
@@ -19,7 +19,7 @@ export const pushCopySql = (
   const target = 'from' in copy ? copy.from : copy.to;
 
   sql.push(
-    `COPY ${q(model.table as string)}${columns} ${
+    `COPY ${q(table.table as string)}${columns} ${
       'from' in copy ? 'FROM' : 'TO'
     } ${
       typeof target === 'string'
@@ -55,5 +55,5 @@ export const pushCopySql = (
     sql.push(`WITH (${options.join(', ')})`);
   }
 
-  pushWhereStatementSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
 };

package/src/sql/delete.ts

@@ -8,11 +8,11 @@ import { DeleteQueryData } from './data';
 
 export const pushDeleteSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: DeleteQueryData,
   quotedAs: string,
 ) => {
-  const from = q(model.table as string);
+  const from = q(table.table as string);
   ctx.sql.push(`DELETE FROM ${from}`);
 
   if (from !== quotedAs) {
@@ -22,7 +22,7 @@ export const pushDeleteSql = (
   let conditions: string | undefined;
   if (query.join?.length) {
     const items = query.join.map((item) =>
-      processJoinItem(ctx, model, item.args, quotedAs),
+      processJoinItem(ctx, table, item.args, quotedAs),
     );
 
     ctx.sql.push(`USING ${items.map((item) => item.target).join(', ')}`);
@@ -33,7 +33,7 @@ export const pushDeleteSql = (
       .join(' AND ');
   }
 
-  pushWhereStatementSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
 
   if (conditions?.length) {
     if (query.and?.length || query.or?.length) {
@@ -43,5 +43,5 @@ export const pushDeleteSql = (
     }
   }
 
-  pushReturningSql(ctx, model, query, quotedAs);
+  pushReturningSql(ctx, table, query, quotedAs);
 };

package/src/sql/fromAndAs.ts

@@ -7,14 +7,14 @@ import { SelectQueryData } from './data';
 
 export const pushFromAndAs = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: SelectQueryData,
   quotedAs?: string,
 ) => {
   ctx.sql.push('FROM');
   if (query.fromOnly) ctx.sql.push('ONLY');
 
-  const from = getFrom(model, query, ctx.values);
+  const from = getFrom(table, query, ctx.values);
   ctx.sql.push(from);
 
   if (query.as && quotedAs && quotedAs !== from) {
@@ -23,7 +23,7 @@ export const pushFromAndAs = (
 };
 
 const getFrom = (
-  model: QueryBase,
+  table: QueryBase,
   query: SelectQueryData,
   values: unknown[],
 ) => {
@@ -51,5 +51,5 @@ const getFrom = (
     return quoteSchemaAndTable(query.schema, query.from);
   }
 
-  return quoteSchemaAndTable(query.schema, model.table as string);
+  return quoteSchemaAndTable(query.schema, table.table as string);
 };