pqb 0.7.13 → 0.8.1

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);
 };

package/src/sql/having.ts

@@ -17,17 +17,17 @@ const aggregateOptionNames: (keyof AggregateItemOptions)[] = [
 
 export const pushHavingSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: SelectQueryData,
   quotedAs?: string,
 ) => {
-  const conditions = havingToSql(ctx, model, query, quotedAs);
+  const conditions = havingToSql(ctx, table, query, quotedAs);
   if (conditions.length) ctx.sql.push('HAVING', conditions);
 };
 
 export const havingToSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: SelectQueryData,
   quotedAs?: string,
 ): string => {
@@ -43,7 +43,7 @@ export const havingToSql = (
   or.forEach((and) => {
     const ands: string[] = [];
     and.forEach((item) => {
-      if ('prototype' in item || '__model' in item) {
+      if ('prototype' in item || '__table' in item) {
         const query = item as QueryBase;
         const sql = havingToSql(
           ctx,
@@ -76,7 +76,7 @@ export const havingToSql = (
                     op as keyof AggregateItemOptions,
                   )
                 ) {
-                  const operator = model.shape[column].operators[
+                  const operator = table.shape[column].operators[
                     op
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                   ] as Operator<any>;
@@ -89,7 +89,7 @@ export const havingToSql = (
 
                   const expression = aggregateToSql(
                     ctx,
-                    model,
+                    table,
                     {
                       function: key,
                       arg: column,
@@ -111,7 +111,7 @@ export const havingToSql = (
               ands.push(
                 `${aggregateToSql(
                   ctx,
-                  model,
+                  table,
                   {
                     function: key,
                     arg: column,

package/src/sql/insert.ts

@@ -9,7 +9,7 @@ import { InsertQueryData, QueryData } from './data';
 
 export const pushInsertSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: InsertQueryData,
   quotedAs: string,
 ) => {
@@ -87,8 +87,8 @@ export const pushInsertSql = (
     }
   }
 
-  pushWhereStatementSql(ctx, model, query, quotedAs);
-  pushReturningSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
+  pushReturningSql(ctx, table, query, quotedAs);
 };
 
 const encodeRow = (ctx: ToSqlCtx, row: unknown[]) => {
@@ -101,11 +101,11 @@ const encodeRow = (ctx: ToSqlCtx, row: unknown[]) => {
 
 export const pushReturningSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: QueryData,
   quotedAs: string,
 ) => {
   if (query.select) {
-    ctx.sql.push(`RETURNING ${selectToSql(ctx, model, query, quotedAs)}`);
+    ctx.sql.push(`RETURNING ${selectToSql(ctx, table, query, quotedAs)}`);
   }
 };

package/src/sql/join.ts

@@ -22,7 +22,7 @@ type ItemOf3Or4Length =
 
 export const processJoinItem = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   args: JoinItem['args'],
   quotedAs?: string,
 ): { target: string; conditions?: string } => {
@@ -31,25 +31,25 @@ export const processJoinItem = (
 
   const [first] = args;
   if (typeof first === 'string') {
-    if (first in model.relations) {
+    if (first in table.relations) {
       const {
         key,
         query: toQuery,
         joinQuery,
-      } = (model.relations as Record<string, Relation>)[first];
+      } = (table.relations as Record<string, Relation>)[first];
 
-      const jq = joinQuery(model, toQuery);
+      const jq = joinQuery(table, toQuery);
       const { query } = jq;
 
-      const table = (
+      const tableName = (
         typeof query.from === 'string' ? query.from : jq.table
       ) as string;
 
-      target = quoteSchemaAndTable(query.schema, table);
+      target = quoteSchemaAndTable(query.schema, tableName);
 
       const as = query.as || key;
       const joinAs = q(as as string);
-      if (as !== table) {
+      if (as !== tableName) {
         target += ` AS ${joinAs}`;
       }
 
@@ -60,7 +60,7 @@ export const processJoinItem = (
 
       if (args[1]) {
         const arg = (args[1] as (q: unknown) => QueryBase)(
-          new ctx.onQueryBuilder(jq, jq.shape, model),
+          new ctx.onQueryBuilder(jq, jq.shape, table),
         ).query;
 
         if (arg.and) queryData.and.push(...arg.and);
@@ -70,7 +70,7 @@ export const processJoinItem = (
       conditions = whereToSql(ctx, jq, queryData, joinAs);
     } else {
       target = q(first);
-      conditions = processArgs(args, ctx, model, first, target, quotedAs);
+      conditions = processArgs(args, ctx, table, first, target, quotedAs);
     }
   } else {
     const query = first.query;
@@ -89,9 +89,9 @@ export const processJoinItem = (
       }
     }
 
-    conditions = processArgs(args, ctx, model, first, joinAs, quotedAs);
+    conditions = processArgs(args, ctx, table, first, joinAs, quotedAs);
 
-    const whereSql = whereToSql(ctx, model, query, joinAs);
+    const whereSql = whereToSql(ctx, table, query, joinAs);
     if (whereSql) {
       if (conditions) conditions += ` AND ${whereSql}`;
       else conditions = whereSql;
@@ -104,7 +104,7 @@ export const processJoinItem = (
 const processArgs = (
   args: JoinItem['args'],
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   first: string | QueryWithTable,
   joinAs: string,
   quotedAs?: string,
@@ -114,7 +114,7 @@ const processArgs = (
     if (typeof arg === 'function') {
       let shape;
       if (typeof first === 'string') {
-        shape = model.query.withShapes?.[first];
+        shape = table.query.withShapes?.[first];
         if (!shape) {
           throw new Error('Cannot get shape of `with` statement');
         }
@@ -122,7 +122,7 @@ const processArgs = (
         shape = first.shape;
       }
 
-      const jq = arg(new ctx.onQueryBuilder(first, shape, model));
+      const jq = arg(new ctx.onQueryBuilder(first, shape, table));
       return whereToSql(ctx, jq, jq.query, joinAs);
     } else {
       return getObjectOrRawConditions(arg, ctx.values, quotedAs, joinAs);
@@ -189,7 +189,7 @@ const getObjectOrRawConditions = (
 
 export const pushJoinSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: QueryData & {
     join: JoinItem[];
   },
@@ -198,7 +198,7 @@ export const pushJoinSql = (
   query.join.forEach((item) => {
     const { target, conditions } = processJoinItem(
       ctx,
-      model,
+      table,
       item.args,
       quotedAs,
     );

package/src/sql/select.ts

@@ -65,16 +65,16 @@ const jsonToSql = (
 
 export const pushSelectSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: Pick<SelectQueryData, 'select' | 'join'>,
   quotedAs?: string,
 ) => {
-  ctx.sql.push(selectToSql(ctx, model, query, quotedAs));
+  ctx.sql.push(selectToSql(ctx, table, query, quotedAs));
 };
 
 export const selectToSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: Pick<SelectQueryData, 'select' | 'join'>,
   quotedAs?: string,
 ): string => {
@@ -116,13 +116,13 @@ export const selectToSql = (
           list.push(
             `${(item as SelectFunctionItem).function}(${selectToSql(
               ctx,
-              model,
+              table,
               { select: item.arguments },
               quotedAs,
             )})${item.as ? ` AS ${q((item as { as: string }).as)}` : ''}`,
           );
         } else {
-          list.push(aggregateToSql(ctx, model, item, quotedAs));
+          list.push(aggregateToSql(ctx, table, item, quotedAs));
         }
       }
     });
@@ -160,7 +160,7 @@ const pushSubQuerySql = (
 
       select.length = 0;
       select[0] = { selectAs: { c: first } } as SelectItem;
-      query = query._wrap(query.__model.clone()) as unknown as typeof query;
+      query = query._wrap(query.__table.clone()) as unknown as typeof query;
       query._getOptional(raw(`COALESCE(json_agg("c"), '[]')`));
       break;
     }

package/src/sql/toSql.ts

@@ -35,22 +35,22 @@ export type ToSqlOptions = {
   values?: unknown[];
 };
 
-export const toSql = (model: Query, options?: ToSqlOptions): Sql => {
+export const toSql = (table: Query, options?: ToSqlOptions): Sql => {
   return (
-    (!options?.clearCache && model.query[toSqlCacheKey]) ||
-    (model.query[toSqlCacheKey] = makeSql(model, options))
+    (!options?.clearCache && table.query[toSqlCacheKey]) ||
+    (table.query[toSqlCacheKey] = makeSql(table, options))
   );
 };
 
 export const makeSql = (
-  model: Query,
+  table: Query,
   { values = [] }: ToSqlOptions = {},
 ): Sql => {
-  const query = model.query;
+  const query = table.query;
   const sql: string[] = [];
   const ctx: ToSqlCtx = {
-    whereQueryBuilder: model.whereQueryBuilder,
-    onQueryBuilder: model.onQueryBuilder,
+    whereQueryBuilder: table.whereQueryBuilder,
+    onQueryBuilder: table.onQueryBuilder,
     sql,
     values,
   };
@@ -61,45 +61,45 @@ export const makeSql = (
 
   if (query.type) {
     if (query.type === 'truncate') {
-      if (!model.table) throw new Error('Table is missing for truncate');
+      if (!table.table) throw new Error('Table is missing for truncate');
 
-      pushTruncateSql(ctx, model.table, query);
+      pushTruncateSql(ctx, table.table, query);
       return { text: sql.join(' '), values };
     }
 
     if (query.type === 'columnInfo') {
-      if (!model.table) throw new Error('Table is missing for truncate');
+      if (!table.table) throw new Error('Table is missing for truncate');
 
-      pushColumnInfoSql(ctx, model.table, query);
+      pushColumnInfoSql(ctx, table.table, query);
       return { text: sql.join(' '), values };
     }
 
-    if (!model.table) throw new Error(`Table is missing for ${query.type}`);
+    if (!table.table) throw new Error(`Table is missing for ${query.type}`);
 
-    const quotedAs = q(query.as || model.table);
+    const quotedAs = q(query.as || table.table);
 
     if (query.type === 'insert') {
-      pushInsertSql(ctx, model, query, q(model.table));
+      pushInsertSql(ctx, table, query, q(table.table));
       return { text: sql.join(' '), values };
     }
 
     if (query.type === 'update') {
-      pushUpdateSql(ctx, model, query, quotedAs);
+      pushUpdateSql(ctx, table, query, quotedAs);
       return { text: sql.join(' '), values };
     }
 
     if (query.type === 'delete') {
-      pushDeleteSql(ctx, model, query, quotedAs);
+      pushDeleteSql(ctx, table, query, quotedAs);
       return { text: sql.join(' '), values };
     }
 
     if (query.type === 'copy') {
-      pushCopySql(ctx, model, query, quotedAs);
+      pushCopySql(ctx, table, query, quotedAs);
       return { text: sql.join(' '), values };
     }
   }
 
-  const quotedAs = model.table && q(query.as || model.table);
+  const quotedAs = table.table && q(query.as || table.table);
 
   sql.push('SELECT');
 
@@ -107,23 +107,23 @@ export const makeSql = (
     pushDistinctSql(ctx, query.distinct, quotedAs);
   }
 
-  pushSelectSql(ctx, model, query, quotedAs);
+  pushSelectSql(ctx, table, query, quotedAs);
 
-  if (model.table || query.from) {
-    pushFromAndAs(ctx, model, query, quotedAs);
+  if (table.table || query.from) {
+    pushFromAndAs(ctx, table, query, quotedAs);
   }
 
   if (query.join) {
     pushJoinSql(
       ctx,
-      model,
+      table,
       query as QueryData & { join: JoinItem[] },
       quotedAs,
     );
   }
 
   if (query.and || query.or) {
-    pushWhereStatementSql(ctx, model, query, quotedAs);
+    pushWhereStatementSql(ctx, table, query, quotedAs);
   }
 
   if (query.group) {
@@ -136,7 +136,7 @@ export const makeSql = (
   }
 
   if (query.having || query.havingOr) {
-    pushHavingSql(ctx, model, query, quotedAs);
+    pushHavingSql(ctx, table, query, quotedAs);
   }
 
   if (query.window) {

package/src/sql/update.ts

@@ -13,11 +13,11 @@ import {
 
 export const pushUpdateSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: UpdateQueryData,
   quotedAs: string,
 ) => {
-  const quotedTable = quoteSchemaAndTable(query.schema, model.table as string);
+  const quotedTable = quoteSchemaAndTable(query.schema, table.table as string);
   ctx.sql.push(`UPDATE ${quotedTable}`);
 
   if (quotedTable !== quotedAs) {
@@ -30,8 +30,8 @@ export const pushUpdateSql = (
   processData(ctx, set, query.updateData);
   ctx.sql.push(set.join(', '));
 
-  pushWhereStatementSql(ctx, model, query, quotedAs);
-  pushReturningSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
+  pushReturningSql(ctx, table, query, quotedAs);
 };
 
 const processData = (

package/src/sql/where.ts

@@ -16,11 +16,11 @@ import { QueryData } from './data';
 
 export const pushWhereStatementSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: Pick<QueryData, 'and' | 'or'>,
   quotedAs?: string,
 ) => {
-  const res = whereToSql(ctx, model, query, quotedAs, false);
+  const res = whereToSql(ctx, table, query, quotedAs, false);
   if (res) {
     ctx.sql.push('WHERE', res);
   }
@@ -29,12 +29,12 @@ export const pushWhereStatementSql = (
 export const pushWhereToSql = (
   sql: string[],
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: Pick<QueryData, 'and' | 'or'>,
   quotedAs?: string,
   not?: boolean,
 ) => {
-  const res = whereToSql(ctx, model, query, quotedAs, not);
+  const res = whereToSql(ctx, table, query, quotedAs, not);
   if (res) {
     sql.push(res);
   }
@@ -42,7 +42,7 @@ export const pushWhereToSql = (
 
 export const whereToSql = (
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   query: Pick<QueryData, 'and' | 'or'>,
   quotedAs?: string,
   not?: boolean,
@@ -50,10 +50,10 @@ export const whereToSql = (
   if (query.or) {
     const ors = query.and ? [query.and, ...query.or] : query.or;
     return ors
-      .map((and) => processAnds(and, ctx, model, quotedAs, not))
+      .map((and) => processAnds(and, ctx, table, quotedAs, not))
       .join(' OR ');
   } else if (query.and) {
-    return processAnds(query.and, ctx, model, quotedAs, not);
+    return processAnds(query.and, ctx, table, quotedAs, not);
   } else {
     return undefined;
   }
@@ -62,19 +62,19 @@ export const whereToSql = (
 const processAnds = (
   and: WhereItem[],
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   quotedAs?: string,
   not?: boolean,
 ): string => {
   const ands: string[] = [];
-  and.forEach((data) => processWhere(ands, ctx, model, data, quotedAs, not));
+  and.forEach((data) => processWhere(ands, ctx, table, data, quotedAs, not));
   return ands.join(' AND ');
 };
 
 const processWhere = (
   ands: string[],
   ctx: ToSqlCtx,
-  model: QueryBase,
+  table: QueryBase,
   data: WhereItem,
   quotedAs?: string,
   not?: boolean,
@@ -82,12 +82,12 @@ const processWhere = (
   const prefix = not ? 'NOT ' : '';
 
   if (typeof data === 'function') {
-    const qb = data(new ctx.whereQueryBuilder(model, model.shape));
+    const qb = data(new ctx.whereQueryBuilder(table, table.shape));
     pushWhereToSql(ands, ctx, qb, qb.query, quotedAs, not);
     return;
   }
 
-  if ('prototype' in data || '__model' in data) {
+  if ('prototype' in data || '__table' in data) {
     const query = data as Query;
     const sql = whereToSql(
       ctx,
@@ -110,17 +110,17 @@ const processWhere = (
     const value = (data as Record<string, unknown>)[key];
     if (key === 'AND') {
       const arr = toArray(value as MaybeArray<WhereItem>);
-      ands.push(processAnds(arr, ctx, model, quotedAs, not));
+      ands.push(processAnds(arr, ctx, table, quotedAs, not));
     } else if (key === 'OR') {
       const arr = (value as MaybeArray<WhereItem>[]).map(toArray);
       ands.push(
         arr
-          .map((and) => processAnds(and, ctx, model, quotedAs, not))
+          .map((and) => processAnds(and, ctx, table, quotedAs, not))
           .join(' OR '),
       );
     } else if (key === 'NOT') {
       const arr = toArray(value as MaybeArray<WhereItem>);
-      ands.push(processAnds(arr, ctx, model, quotedAs, !not));
+      ands.push(processAnds(arr, ctx, table, quotedAs, !not));
     } else if (key === 'ON') {
       if (Array.isArray(value)) {
         const item = value as WhereJsonPathEqualsItem;
@@ -129,7 +129,7 @@ const processWhere = (
         const rightColumn = quoteFullColumn(
           item[2],
           getQueryAs({
-            table: model.table,
+            table: table.table,
             query: { as: quotedAs },
           }),
         );
@@ -171,7 +171,7 @@ const processWhere = (
       (joinItems as JoinItem['args'][]).forEach((item) => {
         const { target, conditions } = processJoinItem(
           ctx,
-          model,
+          table,
           item,
           quotedAs,
         );
@@ -193,7 +193,7 @@ const processWhere = (
           )}`,
         );
       } else {
-        const column = model.shape[key];
+        const column = table.shape[key];
         if (!column) {
           // TODO: custom error classes
           throw new Error(`Unknown column ${key} provided to condition`);

package/src/utils.test.ts

@@ -5,6 +5,7 @@ import {
   pushOrNewArray,
   pushOrNewArrayToObject,
   SetOptional,
+  singleQuote,
   SomeIsTrue,
 } from './utils';
 
@@ -90,4 +91,12 @@ describe('utils', () => {
       expect(pushOrNewArray(arr, 123)).toEqual([123]);
     });
   });
+
+  describe('singleQuote', () => {
+    it('should put string into single quotes, escape single quotes and backslashes', () => {
+      expect(singleQuote(`ko`)).toBe(`'ko'`);
+      expect(singleQuote(`k'o`)).toBe(`'k\\'o'`);
+      expect(singleQuote(`k\\'o`)).toBe(`'k\\\\\\'o'`);
+    });
+  });
 });

package/src/utils.ts

@@ -134,3 +134,6 @@ export const pushOrNewArray = <Arr extends unknown[]>(
     return [value] as Arr;
   }
 };
+
+export const singleQuote = (s: string) =>
+  `'${s.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;