pqb 0.0.1 → 0.0.3

package/src/columnSchema/json/discriminatedUnion.ts

@@ -1,83 +1,92 @@
 import { constructType, JSONType, Primitive } from './typeBase';
-import { JSONObject } from './object';
+import { JSONObject, JSONObjectShape } from './object';
 import { JSONLiteral } from './literal';
 
 export interface JSONDiscriminatedUnion<
   Discriminator extends string,
-  Options extends DiscriminatedOptions<Discriminator>,
-> extends JSONType<Options[number]['type'], 'discriminatedUnion'> {
+  DiscriminatorValue extends Primitive,
+  Option extends JSONDiscriminatedObject<Discriminator, DiscriminatorValue>,
+> extends JSONType<Option['type'], 'discriminatedUnion'> {
   discriminator: Discriminator;
-  options: OptionsMap<Discriminator, Options>;
+  discriminatorValue: DiscriminatorValue;
+  options: Map<DiscriminatorValue, Option>;
+  _option: Option;
   // TODO: gave up on deepPartial type
   // deepPartial(): JSONDiscriminatedUnion<
   //   Discriminator,
   //   {
-  //     [Index in keyof Options]: {
-  //       [K in keyof Options[Index]['shape']]: K extends Discriminator
-  //         ? Options[Index]['shape'][K]
-  //         : JSONOptional<Options[Index]['shape'][K]>;
+  //     [Index in keyof Types]: {
+  //       [K in keyof Types[Index]['shape']]: K extends Discriminator
+  //         ? Types[Index]['shape'][K]
+  //         : JSONOptional<Types[Index]['shape'][K]>;
   //     } extends JSONObject<Record<Discriminator, JSONLiteral<Primitive>>>
   //       ? JSONObject<
   //           {
-  //             [K in keyof Options[Index]['shape']]: K extends Discriminator
-  //               ? Options[Index]['shape'][K]
-  //               : JSONOptional<Options[Index]['shape'][K]>;
+  //             [K in keyof Types[Index]['shape']]: K extends Discriminator
+  //               ? Types[Index]['shape'][K]
+  //               : JSONOptional<Types[Index]['shape'][K]>;
   //           },
-  //           Options[Index]['unknownKeys'],
-  //           Options[Index]['catchAllType']
+  //           Types[Index]['unknownKeys'],
+  //           Types[Index]['catchAllType']
   //         >
-  //       : Options[Index];
+  //       : Types[Index];
   //   } & {
-  //     length: Options['length'];
+  //     length: Types['length'];
   //   }
   // >;
 }
 
-type JSONDiscriminatedObject<Discriminator extends string> = JSONObject<
-  Record<Discriminator, JSONLiteral<Primitive>>
->;
-
-type DiscriminatedOptions<Discriminator extends string> = readonly [
-  JSONDiscriminatedObject<Discriminator>,
-  JSONDiscriminatedObject<Discriminator>,
-  ...JSONDiscriminatedObject<Discriminator>[],
-];
-
-type OptionsMap<
+export type JSONDiscriminatedObject<
   Discriminator extends string,
-  Options extends DiscriminatedOptions<Discriminator>,
-> = Map<Options[number]['shape'][Discriminator]['value'], Options[number]>;
+  DiscriminatorValue extends Primitive,
+> = JSONObject<
+  { [K in Discriminator]: JSONLiteral<DiscriminatorValue> } & JSONObjectShape,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  any
+>;
 
 export const discriminatedUnion = <
   Discriminator extends string,
-  Options extends DiscriminatedOptions<Discriminator>,
+  DiscriminatorValue extends Primitive,
+  Types extends [
+    JSONDiscriminatedObject<Discriminator, DiscriminatorValue>,
+    JSONDiscriminatedObject<Discriminator, DiscriminatorValue>,
+    ...JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[],
+  ],
 >(
   discriminator: Discriminator,
-  options: Options,
-) => {
-  const optionsMap: OptionsMap<
-    Discriminator,
-    DiscriminatedOptions<Discriminator>
-  > = new Map();
+  options: Types,
+): JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]> => {
+  const optionsMap: Map<DiscriminatorValue, Types[number]> = new Map();
 
   options.forEach((option) => {
     const discriminatorValue = option.shape[discriminator].value;
-    optionsMap.set(discriminatorValue, option);
+    optionsMap.set(discriminatorValue as DiscriminatorValue, option);
   });
 
-  return constructType<JSONDiscriminatedUnion<Discriminator, Options>>({
+  return constructType<
+    JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types[number]>
+  >({
     dataType: 'discriminatedUnion',
     discriminator,
+    discriminatorValue: undefined as unknown as DiscriminatorValue,
     options: optionsMap,
-    deepPartial(this: JSONDiscriminatedUnion<Discriminator, Options>) {
-      const newOptionsMap: OptionsMap<
+    _option: undefined as unknown as Types[number],
+    deepPartial(
+      this: JSONDiscriminatedUnion<
         Discriminator,
-        DiscriminatedOptions<Discriminator>
-      > = new Map();
+        DiscriminatorValue,
+        Types[number]
+      >,
+    ) {
+      const newOptionsMap: Map<DiscriminatorValue, Types[number]> = new Map();
 
       optionsMap.forEach((option, key) => {
         const partial =
-          option.deepPartial() as unknown as JSONDiscriminatedObject<Discriminator>;
+          option.deepPartial() as unknown as JSONDiscriminatedObject<
+            Discriminator,
+            DiscriminatorValue
+          >;
         partial.shape[discriminator] = option.shape[discriminator];
         newOptionsMap.set(key, partial);
       });

package/src/columnSchema/json/enum.ts

@@ -1,27 +1,27 @@
 import { constructType, JSONType } from './typeBase';
 
-export interface JSONEnum<T extends EnumValues>
-  extends JSONType<T[number], 'enum'> {
+export interface JSONEnum<
+  U extends string = string,
+  T extends [U, ...U[]] = [U],
+> extends JSONType<T[number], 'enum'> {
   enum: { [k in T[number]]: k };
   options: T;
 }
 
-type EnumValues = readonly [string, ...string[]];
-
-export const arrayToEnum = <T extends string, U extends readonly [T, ...T[]]>(
-  items: U,
+export const arrayToEnum = <U extends string, T extends [U, ...U[]]>(
+  items: T,
 ) => {
-  const obj = {} as { [k in U[number]]: k };
+  const obj = {} as { [k in T[number]]: k };
   for (const item of items) {
     obj[item] = item;
   }
   return obj;
 };
 
-export const enumType = <T extends readonly [string, ...string[]]>(
+export const enumType = <U extends string, T extends [U, ...U[]]>(
   options: T,
 ) => {
-  return constructType<JSONEnum<T>>({
+  return constructType<JSONEnum<U, T>>({
     dataType: 'enum',
     enum: arrayToEnum(options),
     options,

package/src/columnSchema/json/lazy.ts

@@ -7,10 +7,12 @@ export interface JSONLazy<T extends JSONTypeAny>
   deepPartial(): JSONLazy<ReturnType<T['deepPartial']>>;
 }
 
-export const lazy = <T extends JSONTypeAny>(fn: () => T) => {
-  constructType<JSONLazy<T>>({
+export const lazy = <T extends JSONTypeAny>(fn: () => T): JSONLazy<T> => {
+  return constructType<JSONLazy<T>>({
     dataType: 'lazy',
-    getter: fn,
+    getter() {
+      return this.typeCache || (this.typeCache = fn());
+    },
     deepPartial(this: JSONLazy<T>) {
       return {
         ...this,

package/src/columnSchema/json/nativeEnum.ts

@@ -7,7 +7,7 @@ export interface JSONNativeEnum<T extends EnumLike>
   options: (number | string)[];
 }
 
-type EnumLike = { [k: string]: string | number; [nu: number]: string };
+export type EnumLike = { [k: string]: string | number; [nu: number]: string };
 
 export const getValidEnumValues = (obj: EnumLike) => {
   const values: (number | string)[] = [];

package/src/columnSchema/json/nullish.ts

@@ -2,7 +2,7 @@ import { JSONTypeAny } from './typeBase';
 
 export type JSONNullish<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
   type: T['type'] | undefined | null;
-  data: T['data'] & { nullable: true };
+  data: T['data'] & { nullable: true; optional: true };
 };
 
 export const nullish = <T extends JSONTypeAny>(type: T): JSONNullish<T> => {

package/src/columnSchema/json/record.ts

@@ -1,36 +1,39 @@
 import { constructType, JSONType, JSONTypeAny } from './typeBase';
 import { JSONNumber, JSONString, scalarTypes } from './scalarTypes';
 
-export interface JSONRecord<Key extends KeyType, Value extends JSONTypeAny>
-  extends JSONType<Record<Key['type'], Value['type']>, 'record'> {
+export interface JSONRecord<
+  Key extends JSONRecordKeyType,
+  Value extends JSONTypeAny,
+> extends JSONType<Record<Key['type'], Value['type']>, 'record'> {
   keyType: Key;
   valueType: Value;
   deepPartial(): JSONRecord<Key, ReturnType<Value['deepPartial']>>;
 }
 
-type KeyType = JSONType<string | number, 'string' | 'number'>;
-type Args<Key extends KeyType, Value extends JSONTypeAny> =
+export type JSONRecordKeyType = JSONType<string | number, 'string' | 'number'>;
+type Args<Key extends JSONRecordKeyType, Value extends JSONTypeAny> =
   | Args2<Key, Value>
   | Args1<Key>;
 
-type Args2<Key extends KeyType, Value extends JSONTypeAny> = [
+type Args2<Key extends JSONRecordKeyType, Value extends JSONTypeAny> = [
   key: Key,
   value: Value,
 ];
 type Args1<Value extends JSONTypeAny> = [value: Value];
 
-export function record(
-  ...args: Args<JSONString | JSONNumber, JSONTypeAny>
-): JSONRecord<JSONString | JSONNumber, JSONTypeAny> {
+export function record<
+  KeyType extends JSONString | JSONNumber,
+  ValueType extends JSONTypeAny,
+>(...args: Args<KeyType, ValueType>): JSONRecord<KeyType, ValueType> {
   const [keyType, valueType] = (
     args.length === 1 ? [scalarTypes.string(), args[0]] : args
-  ) as Args2<JSONString | JSONNumber, JSONTypeAny>;
+  ) as Args2<KeyType, ValueType>;
 
-  return constructType<JSONRecord<JSONString | JSONNumber, JSONTypeAny>>({
+  return constructType<JSONRecord<KeyType, ValueType>>({
     dataType: 'record',
     keyType,
     valueType,
-    deepPartial(this: JSONRecord<JSONString, JSONTypeAny>) {
+    deepPartial(this: JSONRecord<KeyType, ValueType>) {
       return {
         ...this,
         valueType: this.valueType.deepPartial(),

package/src/columnSchema/json/scalarTypes.ts

@@ -1,7 +1,12 @@
 import { constructType, JSONType, JSONTypeAny } from './typeBase';
 import { BaseNumberData } from '../number';
 import { BaseStringData } from '../string';
-import { numberTypeMethods, stringTypeMethods } from '../commonMethods';
+import {
+  dateTypeMethods,
+  numberTypeMethods,
+  stringTypeMethods,
+} from '../commonMethods';
+import { DateColumnData } from '../dateTime';
 
 export type JSONAny = JSONTypeAny & {
   dataType: 'any';
@@ -17,7 +22,7 @@ export type JSONBigInt = JSONType<bigint, 'bigint'> & {
 } & typeof bigIntMethods;
 const bigIntMethods = {
   dataType: 'bigint' as const,
-  ...numberTypeMethods<JSONType<bigint, 'bigint'> & { data: BaseNumberData }>(),
+  ...numberTypeMethods,
 };
 const bigint = () => {
   return constructType<JSONBigInt>(bigIntMethods);
@@ -55,25 +60,29 @@ export type JSONNumber = JSONType<number, 'number'> & {
   data: BaseNumberData;
 } & typeof numberMethods;
 const numberMethods = {
-  ...numberTypeMethods<JSONType<number, 'number'> & { data: BaseNumberData }>(),
+  ...numberTypeMethods,
   dataType: 'number' as const,
 };
 const number = () => {
   return constructType<JSONNumber>(numberMethods);
 };
 
-export type JSONDate = JSONType<Date, 'date'>;
+export type JSONDate = JSONType<Date, 'date'> & {
+  data: DateColumnData;
+} & typeof dateTypeMethods;
+const dateMethods = {
+  ...dateTypeMethods,
+  dataType: 'date' as const,
+};
 const date = () => {
-  return constructType<JSONDate>({
-    dataType: 'date',
-  });
+  return constructType<JSONDate>(dateMethods);
 };
 
 export type JSONString = JSONType<string, 'string'> & {
   data: BaseStringData;
 } & typeof stringMethods;
 const stringMethods = {
-  ...stringTypeMethods<JSONType<number, 'string'> & { data: BaseStringData }>(),
+  ...stringTypeMethods(),
   dataType: 'string' as const,
 };
 const string = () => {

package/src/columnSchema/json/set.ts

@@ -1,13 +1,13 @@
 import { constructType, JSONType, JSONTypeAny, JSONTypeData } from './typeBase';
-import { ArrayMethods, arrayMethods } from '../commonMethods';
+import { SetMethods, setMethods } from '../commonMethods';
 
 export interface JSONSet<Value extends JSONTypeAny>
   extends JSONType<Set<Value['type']>, 'set'>,
-    ArrayMethods {
+    SetMethods {
   data: JSONTypeData & {
     min?: number;
     max?: number;
-    length?: number;
+    size?: number;
   };
   valueType: Value;
   deepPartial(): JSONSet<ReturnType<Value['deepPartial']>>;
@@ -29,6 +29,6 @@ export const set = <Value extends JSONTypeAny>(valueType: Value) => {
         data: { min: 1 };
       };
     },
-    ...arrayMethods,
+    ...setMethods,
   });
 };

package/src/columnSchema/json/tuple.ts

@@ -5,6 +5,8 @@ export interface JSONTuple<
   Rest extends JSONTypeAny | null = null,
 > extends JSONType<OutputTypeOfTupleWithRest<T, Rest>, 'tuple'> {
   items: T;
+  restType: Rest;
+  rest<Rest extends JSONTypeAny | null>(rest: Rest): JSONTuple<T, Rest>;
   deepPartial(): {
     [k in keyof T]: T[k] extends JSONTypeAny ? DeepPartial<T[k]> : never;
   } extends infer PI
@@ -26,10 +28,23 @@ export type OutputTypeOfTupleWithRest<
   ? [...OutputTypeOfTuple<T>, ...Rest['type'][]]
   : OutputTypeOfTuple<T>;
 
-export const tuple = <T extends JSONTupleItems | []>(items: T) => {
-  return constructType<JSONTuple<T>>({
+export const tuple = <
+  T extends JSONTupleItems | [],
+  Rest extends JSONTypeAny | null = null,
+>(
+  items: T,
+  rest: Rest = null as Rest,
+) => {
+  return constructType<JSONTuple<T, Rest>>({
     dataType: 'tuple',
     items,
+    restType: rest,
+    rest<Rest extends JSONTypeAny | null>(rest: Rest): JSONTuple<T, Rest> {
+      return {
+        ...this,
+        restType: rest,
+      } as unknown as JSONTuple<T, Rest>;
+    },
     deepPartial(this: JSONTuple<T>) {
       return {
         ...this,

package/src/columnSchema/json/typeBase.ts

@@ -9,6 +9,7 @@ import { JSONNotNullish, JSONNullish, notNullish, nullish } from './nullish';
 import { intersection, JSONIntersection } from './intersection';
 import { array, JSONArray } from './array';
 import { union } from './union';
+import { ColumnData, ValidationContext } from '../columnType';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type JSONTypeAny = JSONType<any, string>;
@@ -19,22 +20,22 @@ export type DeepPartial<T extends JSONTypeAny> = ReturnType<
   ? T
   : ReturnType<T['deepPartial']>;
 
-export type JSONTypeData = {
+export type JSONTypeData = ColumnData & {
   optional?: true;
   nullable?: true;
 };
 
 export type Primitive = string | number | bigint | boolean | null | undefined;
 
-export type JSONType<Type, DataType> = {
+export type JSONType<Type, DataType extends string = string> = {
   type: Type;
   data: JSONTypeData;
   dataType: DataType;
   chain: (
-    | ['transform', (input: unknown) => unknown]
+    | ['transform', (input: unknown, ctx: ValidationContext) => unknown]
     | ['to', (input: unknown) => JSONTypeAny | undefined, JSONTypeAny]
     | ['refine', (input: unknown) => unknown]
-    | ['superRefine', (input: unknown) => unknown]
+    | ['superRefine', (input: unknown, ctx: ValidationContext) => unknown]
   )[];
 
   optional<T extends JSONTypeAny>(this: T): JSONOptional<T>;
@@ -47,7 +48,7 @@ export type JSONType<Type, DataType> = {
 
   transform<T extends JSONTypeAny, Transformed>(
     this: T,
-    fn: (input: T['type']) => Transformed,
+    fn: (input: T['type'], ctx: ValidationContext) => Transformed,
   ): JSONType<
     Transformed extends PromiseLike<unknown>
       ? Awaited<Transformed>
@@ -68,7 +69,7 @@ export type JSONType<Type, DataType> = {
 
   superRefine<T extends JSONTypeAny, RefinedOutput extends T['type']>(
     this: T,
-    check: (arg: T['type']) => unknown,
+    check: (arg: T['type'], ctx: ValidationContext) => unknown,
   ): T & { type: RefinedOutput };
 
   and<A extends JSONTypeAny, B extends JSONTypeAny>(
@@ -126,7 +127,7 @@ const baseTypeMethods: JSONTypeAny = {
 
   transform<T extends JSONTypeAny, Transformed>(
     this: T,
-    fn: (input: unknown) => Transformed,
+    fn: (input: unknown, ctx: ValidationContext) => Transformed,
   ) {
     return {
       ...this,
@@ -165,15 +166,9 @@ const baseTypeMethods: JSONTypeAny = {
   },
 
   default(value) {
-    const defaultFn =
-      typeof value === 'function'
-        ? (input: unknown) => input ?? (value as () => unknown)()
-        : (input: unknown) => input ?? value;
-
-    return notNullish({
-      ...this,
-      chain: ['transform', defaultFn],
-    });
+    const cloned = Object.create(this);
+    cloned.data = { ...cloned.data, default: value };
+    return cloned;
   },
 
   array() {

package/src/columnSchema/json/union.ts

@@ -8,7 +8,7 @@ export interface JSONUnion<
 
 export const union = <T extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]>(
   types: T,
-): T[number] => {
+): JSONUnion<T> => {
   return constructType<JSONUnion<T>>({
     dataType: 'union',
     types,

package/src/columnSchema/json.ts

@@ -1,5 +1,5 @@
-import { ColumnType } from './columnType';
-import { Operators } from '../operators';
+import { ColumnData, ColumnType } from './columnType';
+import { Operators } from '../columnsOperators';
 import { scalarTypes } from './json/scalarTypes';
 import { array } from './json/array';
 import { discriminatedUnion } from './json/discriminatedUnion';
@@ -21,7 +21,7 @@ import { union } from './json/union';
 import { JSONTypeAny } from './json/typeBase';
 
 export type JSONTypes = typeof jsonTypes;
-const jsonTypes = {
+export const jsonTypes = {
   array,
   discriminatedUnion,
   enum: enumType,
@@ -47,7 +47,7 @@ export class JSONColumn<
 > extends ColumnType<Type['type'], typeof Operators.json> {
   dataType = 'jsonb' as const;
   operators = Operators.json;
-  data: { schema: Type };
+  data: ColumnData & { schema: Type };
 
   constructor(schemaOrFn: Type | ((j: JSONTypes) => Type)) {
     super();

package/src/columnSchema/number.ts

@@ -1,49 +1,61 @@
-import { Operators } from '../operators';
-import { ColumnType } from './columnType';
+import { Operators } from '../columnsOperators';
+import { ColumnData, ColumnType } from './columnType';
 import { joinTruthy } from '../utils';
 import { assignMethodsToClass } from './utils';
 import { numberTypeMethods } from './commonMethods';
 
-export interface BaseNumberData {
+export type BaseNumberData = ColumnData & {
   lt?: number;
   lte?: number;
   gt?: number;
   gte?: number;
   multipleOf?: number;
-}
+  int?: boolean;
+};
 
 export type NumberColumn = ColumnType<number>;
 
 export type NumberColumnData = BaseNumberData;
 
-type NumberMethods = typeof numberMethods;
-const numberMethods = numberTypeMethods<ColumnType>();
+type NumberMethods = typeof numberTypeMethods;
 
-export interface NumberBaseColumn<Type>
-  extends ColumnType<Type, typeof Operators.number>,
+export interface NumberBaseColumn
+  extends ColumnType<number, typeof Operators.number>,
     NumberMethods {}
 
-export abstract class NumberBaseColumn<Type> extends ColumnType<
-  Type,
+export abstract class NumberBaseColumn extends ColumnType<
+  number,
   typeof Operators.number
 > {
   data = {} as NumberColumnData;
   operators = Operators.number;
 }
 
-assignMethodsToClass(NumberBaseColumn, numberMethods);
+assignMethodsToClass(NumberBaseColumn, numberTypeMethods);
+
+export abstract class IntegerBaseColumn extends NumberBaseColumn {
+  data = { int: true } as NumberColumnData;
+}
 
-export interface DecimalColumnData extends NumberColumnData {
+export abstract class NumberAsStringBaseColumn extends ColumnType<
+  string,
+  typeof Operators.number
+> {
+  data = {};
+  operators = Operators.number;
+}
+
+export type DecimalColumnData = ColumnData & {
   precision?: number;
   scale?: number;
-}
+};
 
 export class DecimalBaseColumn<
-  Type extends number | bigint,
   Precision extends number | undefined = undefined,
   Scale extends number | undefined = undefined,
-> extends NumberBaseColumn<Type> {
+> extends ColumnType<string, typeof Operators.number> {
   data: DecimalColumnData & { precision: Precision; scale: Scale };
+  operators = Operators.number;
   dataType = 'decimal' as const;
 
   constructor(precision?: Precision, scale?: Scale) {
@@ -70,17 +82,19 @@ export class DecimalBaseColumn<
 }
 
 // signed two-byte integer
-export class SmallIntColumn extends NumberBaseColumn<number> {
+export class SmallIntColumn extends IntegerBaseColumn {
   dataType = 'smallint' as const;
+  parseItem = parseInt;
 }
 
 // signed four-byte integer
-export class IntegerColumn extends NumberBaseColumn<number> {
+export class IntegerColumn extends IntegerBaseColumn {
   dataType = 'integer' as const;
+  parseItem = parseInt;
 }
 
 // signed eight-byte integer
-export class BigIntColumn extends NumberBaseColumn<bigint> {
+export class BigIntColumn extends NumberAsStringBaseColumn {
   dataType = 'bigint' as const;
 }
 
@@ -88,35 +102,32 @@ export class BigIntColumn extends NumberBaseColumn<bigint> {
 export class DecimalColumn<
   Precision extends number | undefined = undefined,
   Scale extends number | undefined = undefined,
-> extends DecimalBaseColumn<number, Precision, Scale> {}
-
-// exact numeric of selectable precision, bigint JS type
-export class DecimalBigIntColumn<
-  Precision extends number | undefined = undefined,
-  Scale extends number | undefined = undefined,
-> extends DecimalBaseColumn<bigint, Precision, Scale> {}
+> extends DecimalBaseColumn<Precision, Scale> {}
 
 // single precision floating-point number (4 bytes)
-export class RealColumn extends NumberBaseColumn<number> {
+export class RealColumn extends NumberBaseColumn {
   dataType = 'real' as const;
+  parseItem = parseFloat;
 }
 
 // double precision floating-point number (8 bytes)
-export class DoublePrecisionColumn extends NumberBaseColumn<bigint> {
+export class DoublePrecisionColumn extends NumberAsStringBaseColumn {
   dataType = 'double precision' as const;
 }
 
 // autoincrementing two-byte integer
-export class SmallSerialColumn extends NumberBaseColumn<number> {
+export class SmallSerialColumn extends IntegerBaseColumn {
   dataType = 'smallserial' as const;
+  parseItem = parseInt;
 }
 
 // autoincrementing four-byte integer
-export class SerialColumn extends NumberBaseColumn<number> {
+export class SerialColumn extends IntegerBaseColumn {
   dataType = 'serial' as const;
+  parseItem = parseInt;
 }
 
 // autoincrementing eight-byte integer
-export class BigSerialColumn extends NumberBaseColumn<bigint> {
+export class BigSerialColumn extends NumberAsStringBaseColumn {
   dataType = 'bigserial' as const;
 }