pqb 0.0.1 → 0.0.3

package/src/columnSchema/string.ts

@@ -1,11 +1,11 @@
-import { ColumnType } from './columnType';
-import { Operators } from '../operators';
+import { ColumnData, ColumnType } from './columnType';
+import { Operators } from '../columnsOperators';
 import { joinTruthy } from '../utils';
 import { NumberBaseColumn } from './number';
 import { assignMethodsToClass } from './utils';
 import { stringTypeMethods } from './commonMethods';
 
-export interface BaseStringData {
+export type BaseStringData = ColumnData & {
   min?: number;
   max?: number;
   length?: number;
@@ -14,15 +14,17 @@ export interface BaseStringData {
   uuid?: boolean;
   cuid?: boolean;
   regex?: RegExp;
+  startsWith?: string;
+  endsWith?: string;
   trim?: boolean;
-}
+};
 
 export type StringColumn = ColumnType<string>;
 
 export type TextColumnData = BaseStringData;
 
 type TextMethods = typeof textMethods;
-const textMethods = stringTypeMethods<ColumnType<string>>();
+const textMethods = stringTypeMethods();
 
 export interface TextBaseColumn
   extends ColumnType<string, typeof Operators.text>,
@@ -57,14 +59,14 @@ export abstract class LimitedTextBaseColumn<
   }
 }
 
-// character varying(n), varchar(n)	variable-length with limit
+// character varying(n), varchar(n) variable-length with limit
 export class VarCharColumn<
   Limit extends number | undefined = undefined,
 > extends LimitedTextBaseColumn<Limit> {
   dataType = 'varchar' as const;
 }
 
-// character(n), char(n)	fixed-length, blank padded
+// character(n), char(n) fixed-length, blank padded
 export class CharColumn<
   Limit extends number | undefined = undefined,
 > extends LimitedTextBaseColumn<Limit> {
@@ -72,14 +74,15 @@ export class CharColumn<
 }
 
 // text	variable unlimited length
-export class TextColumn extends ColumnType<string> {
+export class TextColumn extends TextBaseColumn {
   dataType = 'text' as const;
   operators = Operators.text;
 }
 
 // To store binary strings
-export class ByteaColumn extends NumberBaseColumn<string> {
+export class ByteaColumn extends ColumnType<Buffer, typeof Operators.text> {
   dataType = 'bytea' as const;
+  operators = Operators.text;
 }
 
 // point	16 bytes	Point on a plane	(x,y)
@@ -125,8 +128,12 @@ export class CircleColumn extends ColumnType<string, typeof Operators.text> {
   operators = Operators.text;
 }
 
-export class MoneyColumn extends NumberBaseColumn<string> {
+export class MoneyColumn extends NumberBaseColumn {
   dataType = 'money' as const;
+
+  parseFn = (input: unknown) => {
+    return parseFloat((input as string).replace(/,/g, '').replace(/\$/g, ''));
+  };
 }
 
 // cidr	7 or 19 bytes	IPv4 and IPv6 networks
@@ -156,14 +163,15 @@ export class MacAddr8Column extends ColumnType<string, typeof Operators.text> {
 // Bit strings are strings of 1's and 0's.
 // They can be used to store or visualize bit masks.
 // There are two SQL bit types: bit(n) and bit varying(n), where n is a positive integer.
-export class BitColumn<
-  Length extends number | undefined = undefined,
-> extends ColumnType<string, typeof Operators.text> {
+export class BitColumn<Length extends number> extends ColumnType<
+  string,
+  typeof Operators.text
+> {
   dataType = 'bit' as const;
   operators = Operators.text;
-  data: { length: Length };
+  data: ColumnData & { length: Length };
 
-  constructor(length?: Length) {
+  constructor(length: Length) {
     super();
 
     this.data = { length } as { length: Length };
@@ -182,9 +190,9 @@ export class BitVaryingColumn<
 > extends ColumnType<string, typeof Operators.text> {
   dataType = 'bit varying' as const;
   operators = Operators.text;
-  data: { length: Length };
+  data: ColumnData & { length: Length };
 
-  constructor(length?: Length) {
+  constructor(length: Length) {
     super();
 
     this.data = { length } as { length: Length };
@@ -210,13 +218,14 @@ export class TsQueryColumn extends ColumnType<string, typeof Operators.text> {
   operators = Operators.text;
 }
 
-// A tsquery value stores lexemes that are to be searched for
+// uuid stores Universally Unique Identifiers (UUID)
 export class UUIDColumn extends ColumnType<string, typeof Operators.text> {
   dataType = 'uuid' as const;
   operators = Operators.text;
 }
 
+// xml data type can be used to store XML data
 export class XMLColumn extends ColumnType<string, typeof Operators.text> {
-  dataType = 'uuid' as const;
+  dataType = 'xml' as const;
   operators = Operators.text;
 }

package/src/columnSchema/utils.ts

@@ -1,5 +1,3 @@
-export type EmptyObject = Record<never, never>;
-
 export const cloneInstance = <T>(instance: T): T => {
   return Object.assign(
     Object.create(Object.getPrototypeOf(instance)),

package/src/common.ts

@@ -55,22 +55,24 @@ export type ExpressionOutput<
   ? ColumnType
   : never;
 
-export const raw = <C extends ColumnType>(sql: string, ...values: unknown[]) =>
-  ({
-    __raw: sql,
-    __values: values,
-  } as RawExpression<C>);
-
-export const rawColumn = <C extends ColumnType>(
-  column: C,
-  sql: string,
-  ...values: unknown[]
-) =>
-  ({
-    __column: column,
-    __raw: sql,
-    __values: values,
-  } as RawExpression<C>);
+export const raw = <C extends ColumnType>(
+  ...args:
+    | [column: C, sql: string, ...values: unknown[]]
+    | [sql: string, ...values: unknown[]]
+) => {
+  if (typeof args[0] === 'string') {
+    return {
+      __raw: args[0],
+      __values: args.slice(1),
+    } as RawExpression<C>;
+  } else {
+    return {
+      __column: args[0],
+      __raw: args[1],
+      __values: args.slice(2),
+    } as RawExpression<C>;
+  }
+};
 
 export const isRaw = (obj: object): obj is RawExpression => '__raw' in obj;
 

package/src/db.ts

@@ -12,9 +12,10 @@ import {
   columnTypes,
   ColumnShapeOutput,
   TableSchema,
-  AnyColumnTypeCreator,
   ColumnShapeInput,
   ColumnTypes,
+  ColumnTypesBase,
+  getColumnTypes,
 } from './columnSchema';
 import { applyMixins } from './utils';
 import { StringKey } from './common';
@@ -120,7 +121,7 @@ export class Db<
         ? undefined
         : this.defaultSelectColumns;
 
-    const columnsParsers: ColumnsParsers = {};
+    const columnsParsers = {} as ColumnsParsers;
     let hasParsers = false;
     for (const key in shape) {
       const column = shape[key];
@@ -148,7 +149,7 @@ export class Db<
 applyMixins(Db, [QueryMethods]);
 Db.prototype.constructor = Db;
 
-type DbResult<CT extends Record<string, AnyColumnTypeCreator>> = Db & {
+type DbResult<CT extends ColumnTypesBase> = Db & {
   <Table extends string, Shape extends ColumnsShape = ColumnsShape>(
     table: Table,
     shape?: ((t: CT) => Shape) | Shape,
@@ -159,14 +160,15 @@ type DbResult<CT extends Record<string, AnyColumnTypeCreator>> = Db & {
   destroy: Adapter['destroy'];
 };
 
-export type DbOptions<
-  CT extends Record<string, AnyColumnTypeCreator> = ColumnTypes,
-> = ({ adapter: Adapter } | Omit<AdapterOptions, 'log'>) &
+export type DbOptions<CT extends ColumnTypesBase = ColumnTypes> = (
+  | { adapter: Adapter }
+  | Omit<AdapterOptions, 'log'>
+) &
   QueryLogOptions & {
     columnTypes?: CT;
   };
 
-export const createDb = <CT extends Record<string, AnyColumnTypeCreator>>({
+export const createDb = <CT extends ColumnTypesBase>({
   log,
   logger,
   columnTypes: ct = columnTypes as unknown as CT,
@@ -194,7 +196,7 @@ export const createDb = <CT extends Record<string, AnyColumnTypeCreator>>({
         adapter,
         qb,
         table as Table,
-        typeof shape === 'function' ? shape(ct) : shape,
+        typeof shape === 'function' ? getColumnTypes(ct, shape) : shape,
         { ...commonOptions, ...options },
       );
     },

package/src/index.ts

@@ -3,16 +3,11 @@ export * from './sql';
 export * from './adapter';
 export * from './common';
 export * from './db';
-export * from './operators';
+export * from './columnsOperators';
 export * from './query';
-export * from './queryMethods/insert';
-export * from './queryMethods/join';
-export * from './queryMethods/transaction';
-export * from './queryMethods/queryMethods';
-export * from './queryMethods/columnInfo';
+export * from './queryMethods';
 export * from './quote';
 export * from './utils';
 export * from './queryDataUtils';
-export * from './queryMethods/then';
 export * from './errors';
 export * from './relations';

package/src/query.ts

@@ -14,10 +14,10 @@ import { ColumnInfo } from './queryMethods/columnInfo';
 import { RelationQueryBase, RelationsBase } from './relations';
 import { WhereQueryBuilder } from './queryMethods/where';
 import { OnQueryBuilder } from './queryMethods/join';
-import { GetArg } from './queryMethods/get';
+import { GetArg, getValueKey } from './queryMethods/get';
 
 export type ColumnParser = (input: unknown) => unknown;
-export type ColumnsParsers = Record<string, ColumnParser>;
+export type ColumnsParsers = Record<string | getValueKey, ColumnParser>;
 
 export type SelectableBase = Record<
   PropertyKey,

package/src/queryMethods/aggregate.ts

@@ -9,19 +9,20 @@ import {
 import { AddQuerySelect, Query, SetQueryReturnsValue } from '../query';
 import { pushQueryValue, removeFromQuery } from '../queryDataUtils';
 import {
+  ArrayColumn,
   BooleanColumn,
   ColumnType,
-  ArrayColumn,
-  NumberColumn,
-  StringColumn,
   IntegerColumn,
   NullableColumn,
+  NumberColumn,
+  StringColumn,
 } from '../columnSchema';
 import { CoalesceString } from '../utils';
 import { OrderArg, WindowArgDeclaration } from './queryMethods';
 import { WhereArg } from './where';
 import { addParserToQuery } from './select';
 import { SelectItem } from '../sql';
+import { getValueKey } from './get';
 
 const allColumns = raw('*');
 
@@ -179,6 +180,8 @@ export class Aggregate {
     );
 
     if (columnType?.parseFn) {
+      addParserToQuery(this.query, getValueKey, columnType.parseFn);
+
       addParserToQuery(
         this.query,
         options?.as || functionName,

package/src/queryMethods/get.ts

@@ -7,7 +7,6 @@ import {
 import { RelationQueryBase } from '../relations';
 import { isRaw, RawExpression } from '../common';
 import { addParserForRawExpression, processSelectArg } from './select';
-import { getQueryAs } from '../utils';
 
 export type GetArg<T extends QueryBase> =
   | keyof T['selectable']
@@ -29,6 +28,9 @@ type GetOptionalResult<
   Arg extends GetArg<T>,
 > = SetQueryReturnsValueOptional<T, UnwrapRaw<T, Arg>>;
 
+export type getValueKey = typeof getValueKey;
+export const getValueKey = Symbol('get');
+
 const _get = <
   T extends Query,
   R extends 'value' | 'valueOrThrow',
@@ -42,14 +44,15 @@ const _get = <
   q.query.take = true;
 
   if (typeof arg === 'object' && isRaw(arg)) {
-    addParserForRawExpression(q, 'value', arg);
+    addParserForRawExpression(q, getValueKey, arg);
     q.query.select = [arg];
   } else {
     q.query.select = [
       processSelectArg(
         q,
-        getQueryAs(q),
+        q.query.as || q.table,
         arg as Exclude<GetArg<T>, RawExpression>,
+        getValueKey,
       ),
     ];
   }

package/src/queryMethods/index.ts

@@ -0,0 +1,22 @@
+export * from './aggregate';
+export * from './callbacks';
+export * from './clear';
+export * from './columnInfo';
+export * from './delete';
+export * from './for';
+export * from './from';
+export * from './get';
+export * from './having';
+export * from './insert';
+export * from './join';
+export * from './json';
+export * from './log';
+export * from './queryMethods';
+export * from './select';
+export * from './then';
+export * from './transaction';
+export * from './union';
+export * from './update';
+export * from './upsert';
+export * from './where';
+export * from './with';

package/src/queryMethods/join.ts

@@ -181,7 +181,7 @@ const _join = <
     } else {
       const shape = q.query.withShapes?.[first as string];
       if (shape) {
-        parsers = {};
+        parsers = {} as ColumnsParsers;
         for (const key in shape) {
           const parser = shape[key].parseFn;
           if (parser) {

package/src/queryMethods/log.ts

@@ -4,9 +4,9 @@ import { quote } from '../quote';
 
 export type QueryLogObject = {
   colors: boolean;
-  beforeQuery(q: Query, sql: Sql): unknown;
-  afterQuery(q: Query, sql: Sql, logData: unknown): void;
-  onError(error: Error, q: Query, sql: Sql, logData: unknown): void;
+  beforeQuery(sql: Sql): unknown;
+  afterQuery(sql: Sql, logData: unknown): void;
+  onError(error: Error, sql: Sql, logData: unknown): void;
 };
 
 export type QueryLogger = {
@@ -74,7 +74,7 @@ export const logParamToLogObject = (
       beforeQuery() {
         return process.hrtime();
       },
-      afterQuery(_, sql, time: [number, number]) {
+      afterQuery(sql, time: [number, number]) {
         logger.log(
           makeMessage(
             colors,
@@ -87,7 +87,7 @@ export const logParamToLogObject = (
           ),
         );
       },
-      onError(error, _, sql, time: [number, number]) {
+      onError(error, sql, time: [number, number]) {
         const message = `Error: ${error.message}`;
 
         logger.error(

package/src/queryMethods/select.test.ts

@@ -13,7 +13,7 @@ import {
   userData,
   useTestDatabase,
 } from '../test-utils';
-import { raw, rawColumn } from '../common';
+import { raw } from '../common';
 import { DateColumn } from '../columnSchema';
 import { addQueryOn } from './join';
 import { RelationQuery, relationQueryKey } from '../relations';
@@ -465,7 +465,7 @@ describe('selectMethods', () => {
 
     it('should parse raw column', async () => {
       const q = User.select({
-        date: rawColumn(
+        date: raw(
           new DateColumn().parse((input) => new Date(input)),
           '"createdAt"',
         ),

package/src/queryMethods/select.ts

@@ -1,6 +1,7 @@
 import {
   AddQuerySelect,
   ColumnParser,
+  ColumnsParsers,
   Query,
   QueryBase,
   QuerySelectAll,
@@ -21,6 +22,7 @@ import {
   RelationQueryBase,
   relationQueryKey,
 } from '../relations';
+import { getValueKey } from './get';
 
 export type SelectArg<T extends QueryBase> =
   | keyof T['selectable']
@@ -86,7 +88,7 @@ type SelectResult<
 
 export const addParserForRawExpression = (
   q: Query,
-  key: string,
+  key: string | getValueKey,
   raw: RawExpression,
 ) => {
   const parser = raw.__column?.parseFn;
@@ -95,7 +97,7 @@ export const addParserForRawExpression = (
 
 export const addParserForSelectItem = <T extends Query>(
   q: T,
-  as: string | undefined,
+  as: string | getValueKey | undefined,
   key: string,
   item: keyof T['selectable'] | Query | RawExpression,
 ) => {
@@ -138,17 +140,18 @@ export const addParserForSelectItem = <T extends Query>(
 
 export const addParserToQuery = (
   query: QueryData,
-  key: string,
+  key: string | getValueKey,
   parser: ColumnParser,
 ) => {
   if (query.parsers) query.parsers[key] = parser;
-  else query.parsers = { [key]: parser };
+  else query.parsers = { [key]: parser } as ColumnsParsers;
 };
 
 export const processSelectArg = <T extends Query>(
   q: T,
   as: string | undefined,
   item: SelectArg<T>,
+  columnAs?: string | getValueKey,
 ): SelectItem => {
   if (typeof item === 'string') {
     if ((q.relations as Record<string, Relation>)[item]) {
@@ -161,16 +164,16 @@ export const processSelectArg = <T extends Query>(
 
         if (table === as) {
           const parser = q.columnsParsers?.[column];
-          if (parser) addParserToQuery(q.query, column, parser);
+          if (parser) addParserToQuery(q.query, columnAs || column, parser);
         } else {
           const parser = (q.query as SelectQueryData).joinedParsers?.[table]?.[
             column
           ];
-          if (parser) addParserToQuery(q.query, column, parser);
+          if (parser) addParserToQuery(q.query, columnAs || column, parser);
         }
       } else {
         const parser = q.columnsParsers?.[item];
-        if (parser) addParserToQuery(q.query, item, parser);
+        if (parser) addParserToQuery(q.query, columnAs || item, parser);
       }
       return item;
     }

package/src/queryMethods/then.ts

@@ -4,6 +4,7 @@ import { NotFoundError } from '../errors';
 import { QueryArraysResult, QueryResult } from '../adapter';
 import { CommonQueryData, Sql } from '../sql';
 import { AfterCallback, BeforeCallback } from './callbacks';
+import { getValueKey } from './get';
 
 export type ThenResult<Res> = <T extends Query>(
   this: T,
@@ -84,7 +85,7 @@ const then = async (
     sql = q.toSql();
 
     if (q.query.log) {
-      logData = q.query.log?.beforeQuery(q, sql);
+      logData = q.query.log.beforeQuery(sql);
     }
 
     const queryResult = await q.query.adapter[
@@ -92,7 +93,7 @@ const then = async (
     ](sql);
 
     if (q.query.log) {
-      q.query.log?.afterQuery(q, sql, logData);
+      q.query.log.afterQuery(sql, logData);
       // set sql to be undefined to prevent logging on error in case if afterCallbacks throws
       sql = undefined;
     }
@@ -112,7 +113,7 @@ const then = async (
     resolve?.(result);
   } catch (error) {
     if (q.query.log && sql && logData) {
-      q.query.log.onError(error as Error, q, sql, logData);
+      q.query.log.onError(error as Error, sql, logData);
     }
     reject?.(error);
   }
@@ -166,19 +167,12 @@ export const parseResult = (
     }
     case 'value': {
       const value = result.rows[0]?.[0];
-      return value !== undefined
-        ? parseValue(value, (result as unknown as QueryArraysResult).fields, q)
-        : undefined;
+      return value !== undefined ? parseValue(value, q) : undefined;
     }
     case 'valueOrThrow': {
       const value = result.rows[0]?.[0];
       if (value === undefined) throw new NotFoundError();
-
-      return parseValue(
-        value,
-        (result as unknown as QueryArraysResult).fields,
-        q,
-      );
+      return parseValue(value, q);
     }
     case 'rowCount': {
       if (q.query.throwOnNotFound && result.rowCount === 0) {
@@ -219,15 +213,10 @@ const parseRows = (
   return rows;
 };
 
-const parseValue = (
-  value: unknown,
-  fields: { name: string }[],
-  query: Query,
-) => {
-  const field = fields[0];
+const parseValue = (value: unknown, query: Query) => {
   if (value !== null) {
     const parsers = getQueryParsers(query);
-    const parser = parsers?.[field.name];
+    const parser = parsers?.[getValueKey];
     if (parser) {
       return parser(value);
     }

package/src/queryMethods/transaction.test.ts

@@ -12,10 +12,10 @@ describe('transaction', () => {
 
       const {
         rows: [{ a }],
-      } = await db.adapter.query('SELECT 1 AS a');
+      } = await db.query.adapter.query('SELECT 1 AS a');
       const {
         rows: [{ b }],
-      } = await db.adapter.query('SELECT 2 AS b');
+      } = await db.query.adapter.query('SELECT 2 AS b');
       return a + b;
     });
 

package/src/queryMethods/transaction.ts

@@ -23,11 +23,11 @@ export class Transaction {
     const log = this.query.log;
     let logData: unknown | undefined;
     if (log) {
-      logData = log.beforeQuery(this, beginSql);
+      logData = log.beforeQuery(beginSql);
     }
     const t = this.query.adapter.transaction((adapter) => {
       if (log) {
-        log.afterQuery(this, beginSql, logData);
+        log.afterQuery(beginSql, logData);
       }
 
       const q = this.clone();
@@ -35,7 +35,7 @@ export class Transaction {
       q.query.inTransaction = true;
 
       if (log) {
-        logData = log.beforeQuery(this, commitSql);
+        logData = log.beforeQuery(commitSql);
       }
       return cb(q);
     });
@@ -43,10 +43,10 @@ export class Transaction {
     if (log) {
       t.then(
         () => {
-          log.afterQuery(this, commitSql, logData);
+          log.afterQuery(commitSql, logData);
         },
         () => {
-          log.afterQuery(this, rollbackSql, logData);
+          log.afterQuery(rollbackSql, logData);
         },
       );
     }

package/src/queryMethods/update.ts

@@ -22,21 +22,18 @@ export type UpdateData<T extends Query> = {
             | { set: WhereArg<T['relations'][K]['model']> }
             | { delete: boolean }
             | { update: UpdateData<T['relations'][K]['model']> }
+            | {
+                create: InsertData<T['relations'][K]['nestedCreateQuery']>;
+              }
             | (T['returnType'] extends 'one' | 'oneOrThrow'
-                ?
-                    | {
-                        create: InsertData<
-                          T['relations'][K]['nestedCreateQuery']
-                        >;
-                      }
-                    | {
-                        upsert: {
-                          update: UpdateData<T['relations'][K]['model']>;
-                          create: InsertData<
-                            T['relations'][K]['nestedCreateQuery']
-                          >;
-                        };
-                      }
+                ? {
+                    upsert: {
+                      update: UpdateData<T['relations'][K]['model']>;
+                      create: InsertData<
+                        T['relations'][K]['nestedCreateQuery']
+                      >;
+                    };
+                  }
                 : never)
         : T['relations'][K]['type'] extends 'hasOne'
         ?

package/src/sql/having.ts

@@ -1,6 +1,6 @@
 import { AggregateItemOptions, HavingItem, SelectQueryData } from './types';
 import { EMPTY_OBJECT, getRaw, isRaw, RawExpression } from '../common';
-import { Operator } from '../operators';
+import { Operator } from '../columnsOperators';
 import { aggregateToSql } from './aggregate';
 import { Query } from '../query';
 import { addValue, q } from './common';