pqb 0.7.13 → 0.8.1

package/src/columnSchema/dateTime.test.ts

@@ -0,0 +1,298 @@
+import {
+  assertType,
+  db,
+  expectSql,
+  userData,
+  useTestDatabase,
+} from '../test-utils/test-utils';
+import {
+  DateColumn,
+  IntervalColumn,
+  TimeColumn,
+  TimeInterval,
+  TimestampColumn,
+  TimestampWithTimeZoneColumn,
+  TimeWithTimeZoneColumn,
+} from './dateTime';
+import { columnTypes } from './columnTypes';
+
+describe('date time columns', () => {
+  useTestDatabase();
+
+  describe('date', () => {
+    it('should output string', async () => {
+      const result = await db.get(
+        db.raw(() => new DateColumn(), `'1999-01-08'::date`),
+      );
+      expect(result).toBe('1999-01-08');
+
+      assertType<typeof result, string>();
+    });
+
+    it('should have toCode', () => {
+      const column = new DateColumn();
+      expect(column.toCode('t')).toBe('t.date()');
+
+      const now = new Date();
+      const s = now.toISOString();
+      expect(column.min(now).max(now).toCode('t')).toBe(
+        `t.date().min(new Date('${s}')).max(new Date('${s}'))`,
+      );
+    });
+  });
+
+  describe('timestamp', () => {
+    it('should output string', async () => {
+      const result = await db.get(
+        db.raw(() => new TimestampColumn(), `'1999-01-08 04:05:06'::timestamp`),
+      );
+      expect(result).toBe('1999-01-08 04:05:06');
+
+      assertType<typeof result, string>();
+    });
+
+    it('should have toCode', () => {
+      expect(new TimestampColumn().toCode('t')).toBe('t.timestamp()');
+      expect(new TimestampColumn(10).toCode('t')).toBe('t.timestamp(10)');
+
+      const now = new Date();
+      const s = now.toISOString();
+      expect(new TimestampColumn().min(now).max(now).toCode('t')).toEqual(
+        `t.timestamp().min(new Date('${s}')).max(new Date('${s}'))`,
+      );
+    });
+  });
+
+  describe('timestamp with time zone', () => {
+    it('should output string', async () => {
+      const result = await db.get(
+        db.raw(
+          () => new TimestampWithTimeZoneColumn(),
+          `'1999-01-08 04:05:06 +0'::timestamptz AT TIME ZONE 'UTC'`,
+        ),
+      );
+      expect(result).toBe('1999-01-08 04:05:06');
+
+      assertType<typeof result, string>();
+    });
+
+    it('should have toCode', () => {
+      expect(new TimestampWithTimeZoneColumn().toCode('t')).toBe(
+        't.timestampWithTimeZone()',
+      );
+      expect(new TimestampWithTimeZoneColumn(10).toCode('t')).toBe(
+        't.timestampWithTimeZone(10)',
+      );
+
+      const now = new Date();
+      const s = now.toISOString();
+      expect(
+        new TimestampWithTimeZoneColumn().min(now).max(now).toCode('t'),
+      ).toEqual(
+        `t.timestampWithTimeZone().min(new Date('${s}')).max(new Date('${s}'))`,
+      );
+    });
+  });
+
+  describe('time', () => {
+    it('should output string', async () => {
+      const result = await db.get(
+        db.raw(() => new TimeColumn(), `'12:00'::time`),
+      );
+      expect(result).toBe('12:00:00');
+
+      assertType<typeof result, string>();
+    });
+
+    it('should have toCode', () => {
+      expect(new TimeColumn().toCode('t')).toBe('t.time()');
+      expect(new TimeColumn(10).toCode('t')).toBe('t.time(10)');
+
+      const now = new Date();
+      const s = now.toISOString();
+      expect(new TimeColumn().min(now).max(now).toCode('t')).toEqual(
+        `t.time().min(new Date('${s}')).max(new Date('${s}'))`,
+      );
+    });
+  });
+
+  describe('time with time zone', () => {
+    it('should output string', async () => {
+      const result = await db.get(
+        db.raw(
+          () => new TimeWithTimeZoneColumn(),
+          `'12:00 +0'::timetz AT TIME ZONE 'UTC'`,
+        ),
+      );
+      expect(result).toBe('12:00:00+00');
+
+      assertType<typeof result, string>();
+    });
+
+    it('should have toCode', () => {
+      expect(new TimeWithTimeZoneColumn().toCode('t')).toBe(
+        't.timeWithTimeZone()',
+      );
+      expect(new TimeWithTimeZoneColumn(10).toCode('t')).toBe(
+        't.timeWithTimeZone(10)',
+      );
+
+      const now = new Date();
+      const s = now.toISOString();
+      expect(
+        new TimeWithTimeZoneColumn().min(now).max(now).toCode('t'),
+      ).toEqual(
+        `t.timeWithTimeZone().min(new Date('${s}')).max(new Date('${s}'))`,
+      );
+    });
+  });
+
+  describe('interval', () => {
+    it('should output string', async () => {
+      const result = await db.get(
+        db.raw(
+          () => new IntervalColumn(),
+          `'1 year 2 months 3 days 4 hours 5 minutes 6 seconds'::interval`,
+        ),
+      );
+      expect(result).toEqual({
+        years: 1,
+        months: 2,
+        days: 3,
+        hours: 4,
+        minutes: 5,
+        seconds: 6,
+      });
+
+      assertType<typeof result, TimeInterval>();
+    });
+
+    it('should have toCode', () => {
+      expect(new IntervalColumn().toCode('t')).toBe('t.interval()');
+      expect(new IntervalColumn('fields').toCode('t')).toBe(
+        "t.interval('fields')",
+      );
+      expect(new IntervalColumn('fields', 10).toCode('t')).toBe(
+        "t.interval('fields', 10)",
+      );
+    });
+  });
+
+  describe('asNumber', () => {
+    it('should parse and encode timestamp as a number', async () => {
+      const UserWithNumberTimestamp = db('user', (t) => ({
+        id: t.serial().primaryKey(),
+        name: t.text(),
+        password: t.text(),
+        createdAt: t.timestamp().asNumber(),
+        updatedAt: t.timestamp().asNumber(),
+      }));
+
+      const now = Date.now();
+
+      const createQuery = UserWithNumberTimestamp.create({
+        ...userData,
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      expectSql(
+        createQuery.toSql(),
+        `
+          INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
+          VALUES ($1, $2, $3, $4)
+          RETURNING *
+        `,
+        [userData.name, userData.password, new Date(now), new Date(now)],
+      );
+
+      const { id } = await createQuery;
+      const user = await UserWithNumberTimestamp.select(
+        'createdAt',
+        'updatedAt',
+      ).find(id);
+
+      assertType<typeof user, { createdAt: number; updatedAt: number }>();
+
+      expect(typeof user.createdAt).toBe('number');
+      expect(typeof user.updatedAt).toBe('number');
+
+      const updateQuery = UserWithNumberTimestamp.find(id).update({
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      expectSql(
+        updateQuery.toSql(),
+        `
+          UPDATE "user"
+          SET "createdAt" = $1, "updatedAt" = $2
+          WHERE "user"."id" = $3
+        `,
+        [new Date(now), new Date(now), id],
+      );
+    });
+  });
+
+  describe('asDate', () => {
+    it('should parse and encode timestamp as a number', async () => {
+      columnTypes
+        .text(0, 100)
+        .encode((input: number) => input)
+        .parse((text) => parseInt(text))
+        .as(columnTypes.integer());
+
+      const UserWithNumberTimestamp = db('user', (t) => ({
+        id: t.serial().primaryKey(),
+        name: t.text(),
+        password: t.text(),
+        createdAt: columnTypes.timestamp().asDate(),
+        updatedAt: columnTypes.timestamp().asDate(),
+      }));
+
+      const now = new Date();
+
+      const createQuery = UserWithNumberTimestamp.create({
+        ...userData,
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      expectSql(
+        createQuery.toSql(),
+        `
+          INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
+          VALUES ($1, $2, $3, $4)
+          RETURNING *
+        `,
+        [userData.name, userData.password, new Date(now), new Date(now)],
+      );
+
+      const { id } = await createQuery;
+      const user = await UserWithNumberTimestamp.select(
+        'createdAt',
+        'updatedAt',
+      ).find(id);
+
+      assertType<typeof user, { createdAt: Date; updatedAt: Date }>();
+
+      expect(user.createdAt).toBeInstanceOf(Date);
+      expect(user.updatedAt).toBeInstanceOf(Date);
+
+      const updateQuery = UserWithNumberTimestamp.find(id).update({
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      expectSql(
+        updateQuery.toSql(),
+        `
+          UPDATE "user"
+          SET "createdAt" = $1, "updatedAt" = $2
+          WHERE "user"."id" = $3
+        `,
+        [now, now, id],
+      );
+    });
+  });
+});

package/src/columnSchema/dateTime.ts

@@ -1,4 +1,4 @@
-import { ColumnData, ColumnType } from './columnType';
+import { Code, columnCode, ColumnData, ColumnType } from './columnType';
 import { Operators } from '../columnsOperators';
 import { joinTruthy } from '../utils';
 import { dateTypeMethods } from './commonMethods';
@@ -37,9 +37,21 @@ export abstract class DateBaseColumn extends ColumnType<
 
 assignMethodsToClass(DateBaseColumn, dateTypeMethods);
 
+const dateDataToCode = (data: DateColumnData) => {
+  let code = '';
+
+  if (data.min) code += `.min(new Date('${data.min.toISOString()}'))`;
+  if (data.max) code += `.max(new Date('${data.max.toISOString()}'))`;
+
+  return code;
+};
+
 // date	4 bytes	date (no time of day)	4713 BC	5874897 AD 1 day
 export class DateColumn extends DateBaseColumn {
   dataType = 'date' as const;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.date()${dateDataToCode(this.data)}`);
+  }
 }
 
 export type DateTimeColumnData = DateColumnData & {
@@ -84,6 +96,14 @@ export class TimestampColumn<
   Precision extends number | undefined = undefined,
 > extends DateTimeBaseClass<Precision> {
   dataType = 'timestamp' as const;
+  toCode(t: string): Code {
+    const { precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.timestamp(${precision || ''})${dateDataToCode(this.data)}`,
+    );
+  }
 }
 
 // timestamp [ (p) ] with time zone	8 bytes	both date and time, with time zone	4713 BC	294276 AD	1 microsecond
@@ -92,6 +112,16 @@ export class TimestampWithTimeZoneColumn<
 > extends DateTimeWithTimeZoneBaseClass<Precision> {
   dataType = 'timestamp with time zone' as const;
   baseDataType = 'timestamp' as const;
+  toCode(t: string): Code {
+    const { precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.timestampWithTimeZone(${precision || ''})${dateDataToCode(
+        this.data,
+      )}`,
+    );
+  }
 }
 
 // time [ (p) ] [ without time zone ]	8 bytes	time of day (no date)	00:00:00	24:00:00	1 microsecond
@@ -99,6 +129,14 @@ export class TimeColumn<
   Precision extends number | undefined = undefined,
 > extends DateTimeBaseClass<Precision> {
   dataType = 'time' as const;
+  toCode(t: string): Code {
+    const { precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.time(${precision || ''})${dateDataToCode(this.data)}`,
+    );
+  }
 }
 
 // time [ (p) ] with time zone	12 bytes	time of day (no date), with time zone	00:00:00+1559	24:00:00-1559	1 microsecond
@@ -107,6 +145,14 @@ export class TimeWithTimeZoneColumn<
 > extends DateTimeWithTimeZoneBaseClass<Precision> {
   dataType = 'time with time zone' as const;
   baseDataType = 'time' as const;
+  toCode(t: string): Code {
+    const { precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.timeWithTimeZone(${precision || ''})${dateDataToCode(this.data)}`,
+    );
+  }
 }
 
 export type TimeInterval = {
@@ -124,7 +170,7 @@ export class IntervalColumn<
   Precision extends number | undefined = undefined,
 > extends ColumnType<TimeInterval, typeof Operators.date> {
   dataType = 'interval' as const;
-  data: DateTimeColumnData & { fields: Fields; precision: Precision };
+  data: ColumnData & { fields: Fields; precision: Precision };
   operators = Operators.date;
 
   constructor(fields?: Fields, precision?: Precision) {
@@ -136,6 +182,17 @@ export class IntervalColumn<
     };
   }
 
+  toCode(t: string): Code {
+    const { fields, precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.interval(${[fields && `'${fields}'`, precision && String(precision)]
+        .filter((part) => part)
+        .join(', ')})`,
+    );
+  }
+
   toSQL() {
     return joinTruthy(
       this.dataType,

package/src/columnSchema/enum.test.ts

@@ -0,0 +1,33 @@
+import { assertType, db } from '../test-utils/test-utils';
+import { EnumColumn } from './enum';
+
+describe('enum column', () => {
+  beforeAll(async () => {
+    await db.adapter.query(`
+          DROP TYPE IF EXISTS mood
+        `);
+    await db.adapter.query(`
+          CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
+        `);
+  });
+
+  type MoodUnion = 'sad' | 'ok' | 'happy';
+
+  it('should output proper union', async () => {
+    const result = await db.get(
+      db.raw(
+        () => new EnumColumn('mood', ['sad', 'ok', 'happy']),
+        `'happy'::mood`,
+      ),
+    );
+    expect(result).toBe('happy');
+
+    assertType<typeof result, MoodUnion>();
+  });
+
+  it('should have toCode', () => {
+    expect(new EnumColumn('mood', ['sad', 'ok', 'happy']).toCode('t')).toBe(
+      `t.enum('mood', ['sad', 'ok', 'happy'])`,
+    );
+  });
+});

package/src/columnSchema/enum.ts

@@ -1,4 +1,4 @@
-import { ColumnType } from './columnType';
+import { Code, columnCode, ColumnType } from './columnType';
 import { Operators } from '../columnsOperators';
 
 export class EnumColumn<
@@ -12,6 +12,16 @@ export class EnumColumn<
     super();
   }
 
+  toCode(t: string): Code {
+    return columnCode(
+      this,
+      t,
+      `${t}.enum('${this.enumName}', [${this.options
+        .map((option) => `'${option}'`)
+        .join(', ')}])`,
+    );
+  }
+
   toSql() {
     return this.enumName;
   }

package/src/columnSchema/json/array.test.ts

@@ -0,0 +1,21 @@
+import { array } from './array';
+import { scalarTypes } from './scalarTypes';
+
+const { string } = scalarTypes;
+
+describe('array', () => {
+  it('should have toCode', () => {
+    expect(array(string()).toCode('t')).toEqual(['t.string()', '.array()']);
+
+    expect(array(string()).deepPartial().nonEmpty().toCode('t')).toEqual([
+      't.string().optional()',
+      '.array()',
+      '.deepPartial().nonEmpty()',
+    ]);
+
+    expect(array(string()).min(1).max(10).length(15).toCode('t')).toEqual([
+      't.string()',
+      '.array().min(1).max(10).length(15)',
+    ]);
+  });
+});

package/src/columnSchema/json/array.ts

@@ -4,12 +4,14 @@ import {
   JSONType,
   JSONTypeAny,
   JSONTypeData,
+  toCode,
 } from './typeBase';
 import { arrayMethods, ArrayMethods } from '../commonMethods';
+import { toArray } from '../../utils';
 
 export type ArrayCardinality = 'many' | 'atLeastOne';
 
-type arrayOutputType<
+type ArrayOutputType<
   T extends JSONTypeAny,
   Cardinality extends ArrayCardinality = 'many',
 > = Cardinality extends 'atLeastOne'
@@ -19,7 +21,7 @@ type arrayOutputType<
 export interface JSONArray<
   Type extends JSONTypeAny,
   Cardinality extends ArrayCardinality = 'many',
-> extends JSONType<arrayOutputType<Type, Cardinality>, 'array'>,
+> extends JSONType<ArrayOutputType<Type, Cardinality>, 'array'>,
     ArrayMethods {
   data: JSONTypeData & {
     min?: number;
@@ -27,10 +29,9 @@ export interface JSONArray<
     length?: number;
   };
   element: Type;
-  deepPartial(): JSONArray<DeepPartial<Type>, Cardinality>;
-  nonEmpty(
-    this: JSONArray<Type>,
-  ): JSONArray<Type, 'atLeastOne'> & { data: { min: 1 } };
+  deepPartial<T extends JSONArray<Type>>(
+    this: T,
+  ): JSONArray<DeepPartial<Type>, Cardinality>;
 }
 
 export const array = <Type extends JSONTypeAny>(
@@ -39,16 +40,29 @@ export const array = <Type extends JSONTypeAny>(
   return constructType<JSONArray<Type>>({
     dataType: 'array' as const,
     element,
-    deepPartial(this: JSONArray<Type>) {
+    toCode(this: JSONArray<Type>, t: string) {
+      let code = '.array()';
+
+      const { min, max, length, isNonEmpty } = this.data;
+
+      if (min !== undefined && (!isNonEmpty || (isNonEmpty && min !== 1)))
+        code += `.min(${min})`;
+
+      if (max !== undefined) code += `.max(${max})`;
+
+      if (length !== undefined) code += `.length(${length})`;
+
+      return toCode(this, t, [...toArray(this.element.toCode(t)), code]);
+    },
+    deepPartial<T extends JSONArray<Type>>(this: T) {
       return {
         ...this,
         element: this.element.deepPartial(),
-      };
-    },
-    nonEmpty(this: JSONArray<Type>) {
-      return this.min(1) as unknown as JSONArray<Type, 'atLeastOne'> & {
-        data: { min: 1 };
-      };
+        data: {
+          ...this.data,
+          isDeepPartial: true,
+        },
+      } as T;
     },
     ...arrayMethods,
   });

package/src/columnSchema/json/discriminatedUnion.test.ts

@@ -0,0 +1,32 @@
+import { scalarTypes } from './scalarTypes';
+import { discriminatedUnion } from './discriminatedUnion';
+import { object } from './object';
+import { literal } from './literal';
+
+describe('discriminatedUnion', () => {
+  it('should have toCode', () => {
+    expect(
+      discriminatedUnion('type', [
+        object({
+          type: literal('one'),
+          a: scalarTypes.string(),
+        }),
+        object({
+          type: literal('two'),
+          b: scalarTypes.number(),
+        }),
+      ]).toCode('t'),
+    ).toEqual([
+      `t.discriminatedUnion('type', [`,
+      [
+        't.object({',
+        [`type: t.literal('one'),`, `a: t.string(),`],
+        '})',
+        't.object({',
+        [`type: t.literal('two'),`, `b: t.number(),`],
+        '})',
+      ],
+      '])',
+    ]);
+  });
+});

package/src/columnSchema/json/discriminatedUnion.ts

@@ -1,6 +1,7 @@
-import { constructType, JSONType, Primitive } from './typeBase';
+import { constructType, JSONType, Primitive, toCode } from './typeBase';
 import { JSONObject, JSONObjectShape } from './object';
 import { JSONLiteral } from './literal';
+import { singleQuote } from '../../utils';
 
 export interface JSONDiscriminatedUnion<
   Discriminator extends string,
@@ -11,7 +12,7 @@ export interface JSONDiscriminatedUnion<
   discriminatorValue: DiscriminatorValue;
   options: Map<DiscriminatorValue, Option>;
   _option: Option;
-  // TODO: gave up on deepPartial type
+  // WON'T DO: gave up on deepPartial type
   // deepPartial(): JSONDiscriminatedUnion<
   //   Discriminator,
   //   {
@@ -72,6 +73,20 @@ export const discriminatedUnion = <
     discriminatorValue: undefined as unknown as DiscriminatorValue,
     options: optionsMap,
     _option: undefined as unknown as Types[number],
+    toCode(
+      this: JSONDiscriminatedUnion<
+        string,
+        Primitive,
+        JSONDiscriminatedObject<Discriminator, DiscriminatorValue>
+      >,
+      t: string,
+    ) {
+      return toCode(this, t, [
+        `${t}.discriminatedUnion(${singleQuote(this.discriminator)}, [`,
+        options.flatMap((option) => option.toCode(t)),
+        '])',
+      ]);
+    },
     deepPartial(
       this: JSONDiscriminatedUnion<
         Discriminator,

package/src/columnSchema/json/enum.test.ts

@@ -0,0 +1,9 @@
+import { enumType } from './enum';
+
+describe('enum', () => {
+  it('should have toCode', () => {
+    expect(enumType(['a', 'b', 'c']).toCode('t')).toBe(
+      `t.enum(['a', 'b', 'c'])`,
+    );
+  });
+});

package/src/columnSchema/json/enum.ts

@@ -1,4 +1,5 @@
-import { constructType, JSONType } from './typeBase';
+import { constructType, JSONType, toCode } from './typeBase';
+import { singleQuote } from '../../utils';
 
 export interface JSONEnum<
   U extends string = string,
@@ -25,5 +26,12 @@ export const enumType = <U extends string, T extends [U, ...U[]]>(
     dataType: 'enum',
     enum: arrayToEnum(options),
     options,
+    toCode(this: JSONEnum<U, T>, t: string) {
+      return toCode(
+        this,
+        t,
+        `${t}.enum([${options.map(singleQuote).join(', ')}])`,
+      );
+    },
   });
 };