pqb 0.7.13 → 0.8.1

package/src/columnSchema/string.ts

@@ -1,6 +1,6 @@
-import { ColumnData, ColumnType } from './columnType';
+import { Code, columnCode, ColumnData, ColumnType } from './columnType';
 import { Operators } from '../columnsOperators';
-import { joinTruthy } from '../utils';
+import { joinTruthy, singleQuote } from '../utils';
 import { NumberBaseColumn } from './number';
 import { assignMethodsToClass } from './utils';
 import { stringTypeMethods } from './commonMethods';
@@ -17,6 +17,31 @@ export type BaseStringData = ColumnData & {
   startsWith?: string;
   endsWith?: string;
   trim?: boolean;
+  isNonEmpty?: true;
+};
+
+const stringDataToCode = (data: BaseStringData) => {
+  let code = '';
+
+  const { min, isNonEmpty } = data;
+
+  if (min !== undefined && (!isNonEmpty || (isNonEmpty && min !== 1)))
+    code += `.min(${min})`;
+
+  if (data.max !== undefined) code += `.max(${data.max})`;
+  if (data.length !== undefined) code += `.length(${data.length})`;
+  if (data.email !== undefined) code += `.email()`;
+  if (data.url !== undefined) code += `.url()`;
+  if (data.uuid !== undefined) code += `.uuid()`;
+  if (data.cuid !== undefined) code += `.cuid()`;
+  if (data.regex) code += `.regex(${data.regex.toString()})`;
+  if (data.startsWith !== undefined)
+    code += `.startsWith(${singleQuote(data.startsWith)})`;
+  if (data.endsWith !== undefined)
+    code += `.endsWith(${singleQuote(data.endsWith)})`;
+  if (data.cuid !== undefined) code += `.trim()`;
+
+  return code;
 };
 
 export type StringColumn = ColumnType<string>;
@@ -43,18 +68,18 @@ assignMethodsToClass(TextBaseColumn, textMethods);
 export abstract class LimitedTextBaseColumn<
   Limit extends number | undefined = undefined,
 > extends TextBaseColumn {
-  data: TextColumnData & { max: Limit };
+  data: TextColumnData & { arg: Limit };
 
   constructor(limit?: Limit) {
     super();
 
-    this.data = { max: limit } as TextColumnData & { max: Limit };
+    this.data = { arg: limit } as TextColumnData & { arg: Limit };
   }
 
   toSQL() {
     return joinTruthy(
       this.dataType,
-      this.data.max !== undefined && `(${this.data.max})`,
+      this.data.arg !== undefined && `(${this.data.arg})`,
     );
   }
 }
@@ -64,6 +89,14 @@ export class VarCharColumn<
   Limit extends number | undefined = undefined,
 > extends LimitedTextBaseColumn<Limit> {
   dataType = 'varchar' as const;
+  toCode(t: string): Code {
+    const { arg } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.varchar(${arg ?? ''})${stringDataToCode(this.data)}`,
+    );
+  }
 }
 
 // character(n), char(n) fixed-length, blank padded
@@ -71,93 +104,149 @@ export class CharColumn<
   Limit extends number | undefined = undefined,
 > extends LimitedTextBaseColumn<Limit> {
   dataType = 'char' as const;
+  toCode(t: string): Code {
+    const { arg } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.char(${arg ?? ''})${stringDataToCode(this.data)}`,
+    );
+  }
 }
 
 // text	variable unlimited length
 export class TextColumn extends TextBaseColumn {
   dataType = 'text' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.text()${stringDataToCode(this.data)}`);
+  }
 }
 
 // To store binary strings
 export class ByteaColumn extends ColumnType<Buffer, typeof Operators.text> {
   dataType = 'bytea' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.bytea()`);
+  }
 }
 
 // point	16 bytes	Point on a plane	(x,y)
 export class PointColumn extends ColumnType<string, typeof Operators.text> {
   dataType = 'point' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.point()`);
+  }
 }
 
 // line	32 bytes	Infinite line	{A,B,C}
 export class LineColumn extends ColumnType<string, typeof Operators.text> {
-  dataType = 'point' as const;
+  dataType = 'line' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.line()`);
+  }
 }
 
 // lseg	32 bytes	Finite line segment	((x1,y1),(x2,y2))
 export class LsegColumn extends ColumnType<string, typeof Operators.text> {
-  dataType = 'point' as const;
+  dataType = 'lseg' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.lseg()`);
+  }
 }
 
 // box	32 bytes	Rectangular box	((x1,y1),(x2,y2))
 export class BoxColumn extends ColumnType<string, typeof Operators.text> {
-  dataType = 'point' as const;
+  dataType = 'box' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.box()`);
+  }
 }
 
 // path	16+16n bytes	Closed path (similar to polygon)	((x1,y1),...)
 // path	16+16n bytes	Open path	[(x1,y1),...]
 export class PathColumn extends ColumnType<string, typeof Operators.text> {
-  dataType = 'point' as const;
+  dataType = 'path' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.path()`);
+  }
 }
 
 // polygon	40+16n bytes	Polygon (similar to closed path)	((x1,y1),...)
 export class PolygonColumn extends ColumnType<string, typeof Operators.text> {
-  dataType = 'point' as const;
+  dataType = 'polygon' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.polygon()`);
+  }
 }
 
 // circle	24 bytes	Circle	<(x,y),r> (center point and radius)
 export class CircleColumn extends ColumnType<string, typeof Operators.text> {
-  dataType = 'point' as const;
+  dataType = 'circle' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.circle()`);
+  }
 }
 
 export class MoneyColumn extends NumberBaseColumn {
   dataType = 'money' as const;
 
-  parseFn = (input: unknown) => {
-    return parseFloat((input as string).replace(/,/g, '').replace(/\$/g, ''));
-  };
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.money()`);
+  }
+
+  parseFn = Object.assign(
+    function (input: unknown) {
+      return parseFloat((input as string).replace(/,/g, '').replace(/\$/g, ''));
+    },
+    {
+      hideFromCode: true,
+    },
+  );
 }
 
 // cidr	7 or 19 bytes	IPv4 and IPv6 networks
 export class CidrColumn extends ColumnType<string, typeof Operators.text> {
   dataType = 'cidr' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.cidr()`);
+  }
 }
 
 // inet	7 or 19 bytes	IPv4 and IPv6 hosts and networks
 export class InetColumn extends ColumnType<string, typeof Operators.text> {
   dataType = 'inet' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.inet()`);
+  }
 }
 
 // macaddr	6 bytes	MAC addresses
 export class MacAddrColumn extends ColumnType<string, typeof Operators.text> {
   dataType = 'macaddr' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.macaddr()`);
+  }
 }
 
 // macaddr8	8 bytes	MAC addresses (EUI-64 format)
 export class MacAddr8Column extends ColumnType<string, typeof Operators.text> {
   dataType = 'macaddr8' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.macaddr8()`);
+  }
 }
 
 // Bit strings are strings of 1's and 0's.
@@ -177,6 +266,11 @@ export class BitColumn<Length extends number> extends ColumnType<
     this.data = { length } as { length: Length };
   }
 
+  toCode(t: string): Code {
+    const { length } = this.data;
+    return columnCode(this, t, `${t}.bit(${length})`);
+  }
+
   toSQL() {
     return joinTruthy(
       this.dataType,
@@ -192,12 +286,17 @@ export class BitVaryingColumn<
   operators = Operators.text;
   data: ColumnData & { length: Length };
 
-  constructor(length: Length) {
+  constructor(length?: Length) {
     super();
 
     this.data = { length } as { length: Length };
   }
 
+  toCode(t: string): Code {
+    const { length } = this.data;
+    return columnCode(this, t, `${t}.bitVarying(${length ?? ''})`);
+  }
+
   toSQL() {
     return joinTruthy(
       this.dataType,
@@ -210,22 +309,34 @@ export class BitVaryingColumn<
 export class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
   dataType = 'tsvector' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.tsvector()`);
+  }
 }
 
 // A tsquery value stores lexemes that are to be searched for
 export class TsQueryColumn extends ColumnType<string, typeof Operators.text> {
   dataType = 'tsquery' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.tsquery()`);
+  }
 }
 
 // uuid stores Universally Unique Identifiers (UUID)
 export class UUIDColumn extends ColumnType<string, typeof Operators.text> {
   dataType = 'uuid' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.uuid()`);
+  }
 }
 
 // xml data type can be used to store XML data
 export class XMLColumn extends ColumnType<string, typeof Operators.text> {
   dataType = 'xml' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.xml()`);
+  }
 }

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/columnSchema/virtual.ts

@@ -10,6 +10,10 @@ export abstract class VirtualColumn extends ColumnType<
   dataType = '';
   operators = Operators.any;
 
+  toCode(): never {
+    throw new Error(`toCode is not implemented for virtual column`);
+  }
+
   create?(
     q: Query,
     ctx: CreateCtx,

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;