pqb 0.36.12 → 0.36.14

package/dist/index.d.ts

@@ -2209,22 +2209,16 @@ declare class Where {
      *
      * ### JSONB column operators
      *
-     * For the `jsonb` column, note that the `json` type has text operators instead.
+     * JSON functions are available only for the `jsonb` column, note that the `json` type has text operators instead.
      *
-     * `jsonPath` operator: compare a column value under a given JSON path with the provided value.
+     * You can use [jsonPathQueryFirst](/guide/json.html#jsonpathqueryfirst) to filter by a JSON value, follow the link for details.
      *
-     * Value can be of any type to compare with JSON value, or it can be a sub-query or a raw SQL expression.
+     * The value can be of any type, it can also be returned from a sub-query, raw SQL expression.
      *
      * ```ts
-     * db.table.where({
-     *   jsonbColumn: {
-     *     jsonPath: [
-     *       '$.name', // first element is JSON path
-     *       '=', // second argument is comparison operator
-     *       'value', // third argument is a value to compare with
-     *     ],
-     *   },
-     * });
+     * db.table.where((q) =>
+     *   q.get('jsonbColumn').jsonPathQueryFirst('$.name').equals(value),
+     * );
      * ```
      *
      * `jsonSupersetOf`: check if the column value is a superset of provided value.
@@ -2250,7 +2244,7 @@ declare class Where {
      * ```ts
      * db.table.where({
      *   jsonbColumn: {
-     *     jsonSupersetOf: { a: 1 },
+     *     jsonSubsetOf: { a: 1 },
      *   },
      * });
      * ```
@@ -3285,9 +3279,16 @@ type DbOptions<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> = ({
 };
 interface DbTableOptions<ColumnTypes, Table extends string | undefined, Shape extends QueryColumns> extends QueryLogOptions {
     schema?: string;
+    /**
+     * Prepare all SQL queries before executing,
+     * true by default
+     */
     autoPreparedStatements?: boolean;
     noPrimaryKey?: NoPrimaryKeyOption;
     snakeCase?: boolean;
+    /**
+     * Default language for the full text search
+     */
     language?: string;
     /**
      * See {@link ScopeMethods}
@@ -3297,8 +3298,18 @@ interface DbTableOptions<ColumnTypes, Table extends string | undefined, Shape ex
      * See {@link SoftDeleteMethods}
      */
     softDelete?: SoftDeleteOption<Shape>;
+    /**
+     * Table comment, for migrations generator
+     */
     comment?: string;
+    /**
+     * Computed SQL or JS columns definitions
+     */
     computed?: ComputedOptionsFactory<ColumnTypes, Shape>;
+    /**
+     * For customizing `now()` sql, used in soft delete
+     */
+    nowSQL?: string;
 }
 /**
  * See {@link ScopeMethods}
@@ -3497,7 +3508,7 @@ interface DbResult<ColumnTypes> extends Db<string, never, never, never, never, n
  * })
  * ```
  */
-declare const createDb: <SchemaConfig extends ColumnSchemaConfig<ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ log, logger, snakeCase, nowSQL, schemaConfig, columnTypes: ctOrFn, ...options }: DbOptions<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
+declare const createDb: <SchemaConfig extends ColumnSchemaConfig<ColumnTypeBase<orchid_core.ColumnTypeSchemaArg, unknown, any, any, unknown, unknown, any, unknown, any, orchid_core.ColumnDataBase>> = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ log, logger, snakeCase, schemaConfig, columnTypes: ctOrFn, ...options }: DbOptions<SchemaConfig, ColumnTypes>) => DbResult<ColumnTypes>;
 declare const _initQueryBuilder: (adapter: Adapter, columnTypes: unknown, transactionStorage: AsyncLocalStorage<TransactionState>, commonOptions: DbTableOptions<unknown, undefined, QueryColumns>, options: DbSharedOptions) => Db;
 
 interface ToSQLCtx {
@@ -4628,8 +4639,6 @@ type DeleteResult<T extends PickQueryMetaResult> = T['meta']['hasSelect'] extend
 declare const _queryDelete: <T extends PickQueryMetaResult>(query: T) => DeleteResult<T>;
 declare class Delete {
     /**
-     * It is aliased to `del` because `delete` is a reserved word in JavaScript.
-     *
      * This method deletes one or more rows, based on other conditions specified in the query.
      *
      * By default, `delete` will return a count of deleted records.
@@ -6519,7 +6528,7 @@ type OrderArgKey<T extends OrderArgSelf> = {
 type GroupArgs<T extends PickQueryResult> = ({
     [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K;
 }[keyof T['result']] | Expression)[];
-interface QueryHelper<T extends PickQueryMetaShape, Args extends unknown[], Result> {
+interface QueryHelper<T extends PickQueryMetaShape, Args extends any[], Result> {
     <Q extends {
         returnType: QueryReturnType;
         meta: QueryMetaBase & {
@@ -6531,7 +6540,7 @@ interface QueryHelper<T extends PickQueryMetaShape, Args extends unknown[], Resu
     }>(q: Q, ...args: Args): Result extends Query ? MergeQuery<Q, Result> : Result;
     result: Result;
 }
-type QueryHelperResult<T extends QueryHelper<Query, unknown[], unknown>> = T['result'];
+type QueryHelperResult<T extends QueryHelper<Query, any[], unknown>> = T['result'];
 type NarrowTypeResult<T extends PickQueryMetaResultReturnType, Narrow> = {
     [K in keyof T['result']]: K extends keyof Narrow ? {
         [P in keyof T['result'][K]]: P extends 'outputType' ? Narrow[K] extends T['result'][K]['outputType'] ? Narrow[K] : `narrowType() error: passed type does not exist in '${K & string}'s type union` : T['result'][K][P];
@@ -6673,7 +6682,7 @@ declare class QueryMethods<ColumnTypes> {
      * Finds a single record with a given SQL, throws {@link NotFoundError} if not found:
      *
      * ```ts
-     * await db.user.find`
+     * await db.user.findBySql`
      *   age = ${age} AND
      *   name = ${name}
      * `;
@@ -6698,7 +6707,7 @@ declare class QueryMethods<ColumnTypes> {
      * Returns `undefined` when not found.
      *
      * ```ts
-     * await db.user.find`
+     * await db.user.findBySqlOptional`
      *   age = ${age} AND
      *   name = ${name}
      * `;
@@ -7135,6 +7144,7 @@ interface QueryInternal<SinglePrimaryKey = any, UniqueColumns = any, UniqueColum
     extensions?: DbExtension[];
     domains?: DbDomainArgRecord;
     tableData: TableData;
+    nowSQL?: string;
     primaryKeys?: string[];
 }
 type SelectableFromShape<Shape extends QueryColumns, Table extends string | undefined> = {

package/dist/index.js

@@ -1908,18 +1908,6 @@ const columnWithDotToSql = (ctx, data, shape, column, index, quotedAs, select) =
   }
   return `"${tableName}"."${key}"`;
 };
-const columnToSqlWithAs = (ctx, data, column, quotedAs, select) => {
-  const index = column.indexOf(".");
-  return index !== -1 ? tableColumnToSqlWithAs(
-    ctx,
-    data,
-    column,
-    column.slice(0, index),
-    column.slice(index + 1),
-    quotedAs,
-    select
-  ) : ownColumnToSqlWithAs(ctx, data, column, quotedAs, select);
-};
 const tableColumnToSqlWithAs = (ctx, data, column, table, key, quotedAs, select) => {
   var _a, _b, _c;
   if (key === "*") {
@@ -4543,11 +4531,9 @@ class SelectItemExpression extends orchidCore.Expression {
     if (value)
       Object.assign(this, value.operators);
   }
-  // `makeSQL` acts similarly to how select args are handled,
-  // except that it will use non-aliasing `columnToSql` when `ctx.aliasValue` is true,
-  // it is needed for relation sub-queries that returns a single column.
+  // `makeSQL` acts similarly to how select args are handled
   makeSQL(ctx, quotedAs) {
-    return typeof this.item === "string" ? this.item === "*" ? selectAllSql(this.query, this.q, quotedAs) : ctx.aliasValue ? columnToSql(ctx, this.q, this.q.shape, this.item, quotedAs, true) : columnToSqlWithAs(ctx, this.q, this.item, quotedAs, true) : selectedObjectToSQL(ctx, quotedAs, this.item);
+    return typeof this.item === "string" ? this.item === "*" ? selectAllSql(this.query, this.q, quotedAs) : columnToSql(ctx, this.q, this.q.shape, this.item, quotedAs, true) : this.item.toSQL(ctx, quotedAs);
   }
 }
 
@@ -7889,8 +7875,6 @@ const _queryDelete = (query) => {
 };
 class Delete {
   /**
-   * It is aliased to `del` because `delete` is a reserved word in JavaScript.
-   *
    * This method deletes one or more rows, based on other conditions specified in the query.
    *
    * By default, `delete` will return a count of deleted records.
@@ -9833,22 +9817,16 @@ class Where {
    *
    * ### JSONB column operators
    *
-   * For the `jsonb` column, note that the `json` type has text operators instead.
+   * JSON functions are available only for the `jsonb` column, note that the `json` type has text operators instead.
    *
-   * `jsonPath` operator: compare a column value under a given JSON path with the provided value.
+   * You can use [jsonPathQueryFirst](/guide/json.html#jsonpathqueryfirst) to filter by a JSON value, follow the link for details.
    *
-   * Value can be of any type to compare with JSON value, or it can be a sub-query or a raw SQL expression.
+   * The value can be of any type, it can also be returned from a sub-query, raw SQL expression.
    *
    * ```ts
-   * db.table.where({
-   *   jsonbColumn: {
-   *     jsonPath: [
-   *       '$.name', // first element is JSON path
-   *       '=', // second argument is comparison operator
-   *       'value', // third argument is a value to compare with
-   *     ],
-   *   },
-   * });
+   * db.table.where((q) =>
+   *   q.get('jsonbColumn').jsonPathQueryFirst('$.name').equals(value),
+   * );
    * ```
    *
    * `jsonSupersetOf`: check if the column value is a superset of provided value.
@@ -9874,7 +9852,7 @@ class Where {
    * ```ts
    * db.table.where({
    *   jsonbColumn: {
-   *     jsonSupersetOf: { a: 1 },
+   *     jsonSubsetOf: { a: 1 },
    *   },
    * });
    * ```
@@ -11290,14 +11268,14 @@ function enableSoftDelete(q, table, shape, softDelete, scopes) {
   };
   scopes.deleted = scope;
   ((_b = (_a = q.q).scopes) != null ? _b : _a.scopes = {}).nonDeleted = scope;
-  const _del = _softDelete(column);
+  const _del = _softDelete(column, q.internal.nowSQL);
   q.baseQuery.delete = function() {
     return _del.call(this.clone());
   };
 }
 const nowSql = new RawSQL("now()");
-const _softDelete = (column) => {
-  const set = { [column]: nowSql };
+const _softDelete = (column, customNowSQL) => {
+  const set = { [column]: customNowSQL ? new RawSQL(customNowSQL) : nowSql };
   return function() {
     return _queryUpdate(this, set);
   };
@@ -11692,7 +11670,7 @@ class QueryMethods {
    * Finds a single record with a given SQL, throws {@link NotFoundError} if not found:
    *
    * ```ts
-   * await db.user.find`
+   * await db.user.findBySql`
    *   age = ${age} AND
    *   name = ${name}
    * `;
@@ -11722,7 +11700,7 @@ class QueryMethods {
    * Returns `undefined` when not found.
    *
    * ```ts
-   * await db.user.find`
+   * await db.user.findBySqlOptional`
    *   age = ${age} AND
    *   name = ${name}
    * `;
@@ -12345,6 +12323,7 @@ class Db {
       snakeCase: options.snakeCase,
       noPrimaryKey: options.noPrimaryKey === "ignore",
       comment: options.comment,
+      nowSQL: options.nowSQL,
       tableData
     };
     this.baseQuery = this;
@@ -12586,14 +12565,12 @@ const createDb = (_a) => {
     log,
     logger,
     snakeCase,
-    nowSQL,
     schemaConfig = defaultSchemaConfig,
     columnTypes: ctOrFn = makeColumnTypes(schemaConfig)
   } = _b, options = __objRest(_b, [
     "log",
     "logger",
     "snakeCase",
-    "nowSQL",
     "schemaConfig",
     "columnTypes"
   ]);
@@ -12604,6 +12581,7 @@ const createDb = (_a) => {
     logger,
     autoPreparedStatements: (_a2 = options.autoPreparedStatements) != null ? _a2 : false,
     noPrimaryKey: (_b2 = options.noPrimaryKey) != null ? _b2 : "error",
+    nowSQL: options.nowSQL,
     snakeCase
   };
   const ct = typeof ctOrFn === "function" ? ctOrFn(makeColumnTypes(schemaConfig)) : ctOrFn;
@@ -12618,16 +12596,19 @@ const createDb = (_a) => {
     commonOptions,
     options
   );
-  const tableConstructor = (table, shape, dataFn, options2) => new Db(
-    adapter,
-    qb,
-    table,
-    typeof shape === "function" ? getColumnTypes(ct, shape, nowSQL, options2 == null ? void 0 : options2.language) : shape,
-    ct,
-    transactionStorage,
-    __spreadValues(__spreadValues({}, commonOptions), options2),
-    parseTableData(dataFn)
-  );
+  const { nowSQL } = options;
+  const tableConstructor = (table, shape, dataFn, options2) => {
+    return new Db(
+      adapter,
+      qb,
+      table,
+      typeof shape === "function" ? getColumnTypes(ct, shape, nowSQL, options2 == null ? void 0 : options2.language) : shape,
+      ct,
+      transactionStorage,
+      __spreadValues(__spreadValues({}, commonOptions), options2),
+      parseTableData(dataFn)
+    );
+  };
   const db = Object.assign(tableConstructor, qb, {
     adapter,
     close: () => adapter.close()