@vendure/docs 0.0.0-202601161541

package/docs/reference/typescript-api/data-access/hydrate-options.md

@@ -0,0 +1,40 @@
+---
+title: "HydrateOptions"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## HydrateOptions
+
+<GenerationInfo sourceFile="packages/core/src/service/helpers/entity-hydrator/entity-hydrator-types.ts" sourceLine="12" packageName="@vendure/core" since="1.3.0" />
+
+Options used to control which relations of the entity get hydrated
+when using the <a href='/reference/typescript-api/data-access/entity-hydrator#entityhydrator'>EntityHydrator</a> helper.
+
+```ts title="Signature"
+interface HydrateOptions<Entity extends VendureEntity> {
+    relations: Array<EntityRelationPaths<Entity>>;
+    applyProductVariantPrices?: boolean;
+}
+```
+
+<div className="members-wrapper">
+
+### relations
+
+<MemberInfo kind="property" type={`Array&#60;<a href='/reference/typescript-api/common/entity-relation-paths#entityrelationpaths'>EntityRelationPaths</a>&#60;Entity&#62;&#62;`}   />
+
+Defines the relations to hydrate, using strings with dot notation to indicate
+nested joins. If the entity already has a particular relation available, that relation
+will be skipped (no extra DB join will be added).
+### applyProductVariantPrices
+
+<MemberInfo kind="property" type={`boolean`} default={`false`}   />
+
+If set to `true`, any ProductVariants will also have their `price` and `priceWithTax` fields
+applied based on the current context. If prices are not required, this can be left `false` which
+will be slightly more efficient.
+
+
+</div>

package/docs/reference/typescript-api/data-access/index.md

@@ -0,0 +1,5 @@
+---
+title: "Data Access"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->

package/docs/reference/typescript-api/data-access/list-query-builder.md

@@ -0,0 +1,239 @@
+---
+title: "ListQueryBuilder"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## ListQueryBuilder
+
+<GenerationInfo sourceFile="packages/core/src/service/helpers/list-query-builder/list-query-builder.ts" sourceLine="207" packageName="@vendure/core" />
+
+This helper class is used when fetching entities the database from queries which return a <a href='/reference/typescript-api/common/paginated-list#paginatedlist'>PaginatedList</a> type.
+These queries all follow the same format:
+
+In the GraphQL definition, they return a type which implements the `Node` interface, and the query returns a
+type which implements the `PaginatedList` interface:
+
+```GraphQL
+type BlogPost implements Node {
+  id: ID!
+  published: DateTime!
+  title: String!
+  body: String!
+}
+
+type BlogPostList implements PaginatedList {
+  items: [BlogPost!]!
+  totalItems: Int!
+}
+
+# Generated at run-time by Vendure
+input BlogPostListOptions
+
+extend type Query {
+   blogPosts(options: BlogPostListOptions): BlogPostList!
+}
+```
+When Vendure bootstraps, it will find the `BlogPostListOptions` input and, because it is used in a query
+returning a `PaginatedList` type, it knows that it should dynamically generate this input. This means
+all primitive field of the `BlogPost` type (namely, "published", "title" and "body") will have `filter` and
+`sort` inputs created for them, as well a `skip` and `take` fields for pagination.
+
+Your resolver function will then look like this:
+
+```ts
+@Resolver()
+export class BlogPostResolver
+  constructor(private blogPostService: BlogPostService) {}
+
+  @Query()
+  async blogPosts(
+    @Ctx() ctx: RequestContext,
+    @Args() args: any,
+  ): Promise<PaginatedList<BlogPost>> {
+    return this.blogPostService.findAll(ctx, args.options || undefined);
+  }
+}
+```
+
+and the corresponding service will use the ListQueryBuilder:
+
+```ts
+@Injectable()
+export class BlogPostService {
+  constructor(private listQueryBuilder: ListQueryBuilder) {}
+
+  findAll(ctx: RequestContext, options?: ListQueryOptions<BlogPost>) {
+    return this.listQueryBuilder
+      .build(BlogPost, options)
+      .getManyAndCount()
+      .then(async ([items, totalItems]) => {
+        return { items, totalItems };
+      });
+  }
+}
+```
+
+```ts title="Signature"
+class ListQueryBuilder implements OnApplicationBootstrap {
+    constructor(connection: TransactionalConnection, configService: ConfigService)
+    filterObjectHasProperty(filterObject: FP | NullOptionals<FP> | null | undefined, property: keyof FP) => boolean;
+    build(entity: Type<T>, options: ListQueryOptions<T> = {}, extendedOptions: ExtendedListQueryOptions<T> = {}) => SelectQueryBuilder<T>;
+}
+```
+* Implements: <code>OnApplicationBootstrap</code>
+
+
+
+<div className="members-wrapper">
+
+### constructor
+
+<MemberInfo kind="method" type={`(connection: <a href='/reference/typescript-api/data-access/transactional-connection#transactionalconnection'>TransactionalConnection</a>, configService: ConfigService) => ListQueryBuilder`}   />
+
+
+### filterObjectHasProperty
+
+<MemberInfo kind="method" type={`(filterObject: FP | NullOptionals&#60;FP&#62; | null | undefined, property: keyof FP) => boolean`}   />
+
+Used to determine whether a list query `filter` object contains the
+given property, either at the top level or nested inside a boolean
+`_and` or `_or` expression.
+
+This is useful when a custom property map is used to map a filter
+field to a related entity, and we need to determine whether the
+filter object contains that property, which then means we would need
+to join that relation.
+### build
+
+<MemberInfo kind="method" type={`(entity: Type&#60;T&#62;, options: ListQueryOptions&#60;T&#62; = {}, extendedOptions: <a href='/reference/typescript-api/data-access/list-query-builder#extendedlistqueryoptions'>ExtendedListQueryOptions</a>&#60;T&#62; = {}) => SelectQueryBuilder&#60;T&#62;`}   />
+
+
+
+
+</div>
+
+
+## ExtendedListQueryOptions
+
+<GenerationInfo sourceFile="packages/core/src/service/helpers/list-query-builder/list-query-builder.ts" sourceLine="48" packageName="@vendure/core" />
+
+Options which can be passed to the ListQueryBuilder's `build()` method.
+
+```ts title="Signature"
+type ExtendedListQueryOptions<T extends VendureEntity> = {
+    relations?: string[];
+    channelId?: ID;
+    where?: FindOptionsWhere<T>;
+    orderBy?: FindOneOptions<T>['order'];
+    entityAlias?: string;
+    ctx?: RequestContext;
+    customPropertyMap?: { [name: string]: string };
+    ignoreQueryLimits?: boolean;
+}
+```
+
+<div className="members-wrapper">
+
+### relations
+
+<MemberInfo kind="property" type={`string[]`}   />
+
+
+### channelId
+
+<MemberInfo kind="property" type={`<a href='/reference/typescript-api/common/id#id'>ID</a>`}   />
+
+
+### where
+
+<MemberInfo kind="property" type={`FindOptionsWhere&#60;T&#62;`}   />
+
+
+### orderBy
+
+<MemberInfo kind="property" type={`FindOneOptions&#60;T&#62;['order']`}   />
+
+
+### entityAlias
+
+<MemberInfo kind="property" type={`string`}  since="1.6.0"  />
+
+Allows you to specify the alias used for the entity `T` in the generated SQL query.
+Defaults to the entity class name lower-cased, i.e. `ProductVariant` -> `'productvariant'`.
+### ctx
+
+<MemberInfo kind="property" type={`<a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>`}   />
+
+When a RequestContext is passed, then the query will be
+executed as part of any outer transaction.
+### customPropertyMap
+
+<MemberInfo kind="property" type={`{ [name: string]: string }`}   />
+
+One of the main tasks of the ListQueryBuilder is to auto-generate filter and sort queries based on the
+available columns of a given entity. However, it may also be sometimes desirable to allow filter/sort
+on a property of a relation. In this case, the `customPropertyMap` can be used to define a property
+of the `options.sort` or `options.filter` which does not correspond to a direct column of the current
+entity, and then provide a mapping to the related property to be sorted/filtered.
+
+Example: we want to allow sort/filter by and Order's `customerLastName`. The actual lastName property is
+not a column in the Order table, it exists on the Customer entity, and Order has a relation to Customer via
+`Order.customer`. Therefore, we can define a customPropertyMap like this:
+
+*Example*
+
+```GraphQL
+"""
+Manually extend the filter & sort inputs to include the new
+field that we want to be able to use in building list queries.
+"""
+input OrderFilterParameter {
+    customerLastName: StringOperators
+}
+
+input OrderSortParameter {
+    customerLastName: SortOrder
+}
+```
+
+*Example*
+
+```ts
+const qb = this.listQueryBuilder.build(Order, options, {
+  relations: ['customer'],
+  customPropertyMap: {
+    // Tell TypeORM how to map that custom
+    // sort/filter field to the property on a
+    // related entity.
+    customerLastName: 'customer.lastName',
+  },
+};
+```
+We can now use the `customerLastName` property to filter or sort
+on the list query:
+
+*Example*
+
+```GraphQL
+query {
+  myOrderQuery(options: {
+    filter: {
+      customerLastName: { contains: "sm" }
+    }
+  }) {
+    # ...
+  }
+}
+```
+### ignoreQueryLimits
+
+<MemberInfo kind="property" type={`boolean`} default={`false`}  since="2.0.2"  />
+
+When set to `true`, the configured `shopListQueryLimit` and `adminListQueryLimit` values will be ignored,
+allowing unlimited results to be returned. Use caution when exposing an unlimited list query to the public,
+as it could become a vector for a denial of service attack if an attacker requests a very large list.
+
+
+</div>

package/docs/reference/typescript-api/data-access/transactional-connection.md

@@ -0,0 +1,173 @@
+---
+title: "TransactionalConnection"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## TransactionalConnection
+
+<GenerationInfo sourceFile="packages/core/src/connection/transactional-connection.ts" sourceLine="41" packageName="@vendure/core" />
+
+The TransactionalConnection is a wrapper around the TypeORM `Connection` object which works in conjunction
+with the <a href='/reference/typescript-api/request/transaction-decorator#transaction'>Transaction</a> decorator to implement per-request transactions. All services which access the
+database should use this class rather than the raw TypeORM connection, to ensure that db changes can be
+easily wrapped in transactions when required.
+
+The service layer does not need to know about the scope of a transaction, as this is covered at the
+API by the use of the `Transaction` decorator.
+
+```ts title="Signature"
+class TransactionalConnection {
+    constructor(dataSource: DataSource, transactionWrapper: TransactionWrapper)
+    rawConnection: DataSource
+    getRepository(target: ObjectType<Entity> | EntitySchema<Entity> | string) => Repository<Entity>;
+    getRepository(ctx: RequestContext | undefined, target: ObjectType<Entity> | EntitySchema<Entity> | string, options?: {
+            replicationMode?: ReplicationMode;
+        }) => Repository<Entity>;
+    getRepository(ctxOrTarget: RequestContext | ObjectType<Entity> | EntitySchema<Entity> | string | undefined, maybeTarget?: ObjectType<Entity> | EntitySchema<Entity> | string, options?: {
+            replicationMode?: ReplicationMode;
+        }) => Repository<Entity>;
+    withTransaction(work: (ctx: RequestContext) => Promise<T>) => Promise<T>;
+    withTransaction(ctx: RequestContext, work: (ctx: RequestContext) => Promise<T>) => Promise<T>;
+    withTransaction(ctxOrWork: RequestContext | ((ctx: RequestContext) => Promise<T>), maybeWork?: (ctx: RequestContext) => Promise<T>) => Promise<T>;
+    startTransaction(ctx: RequestContext, isolationLevel?: TransactionIsolationLevel) => ;
+    commitOpenTransaction(ctx: RequestContext) => ;
+    rollBackTransaction(ctx: RequestContext) => ;
+    getEntityOrThrow(ctx: RequestContext, entityType: Type<T>, id: ID, options: GetEntityOrThrowOptions<T> = {}) => Promise<T>;
+    findOneInChannel(ctx: RequestContext, entity: Type<T>, id: ID, channelId: ID, options: FindOneOptions<T> = {}) => ;
+    findByIdsInChannel(ctx: RequestContext, entity: Type<T>, ids: ID[], channelId: ID, options: FindManyOptions<T>) => ;
+}
+```
+
+<div className="members-wrapper">
+
+### constructor
+
+<MemberInfo kind="method" type={`(dataSource: DataSource, transactionWrapper: TransactionWrapper) => TransactionalConnection`}   />
+
+
+### rawConnection
+
+<MemberInfo kind="property" type={`DataSource`}   />
+
+The plain TypeORM Connection object. Should be used carefully as any operations
+performed with this connection will not be performed within any outer
+transactions.
+### getRepository
+
+<MemberInfo kind="method" type={`(target: ObjectType&#60;Entity&#62; | EntitySchema&#60;Entity&#62; | string) => Repository&#60;Entity&#62;`}   />
+
+Returns a TypeORM repository. Note that when no RequestContext is supplied, the repository will not
+be aware of any existing transaction. Therefore, calling this method without supplying a RequestContext
+is discouraged without a deliberate reason.
+### getRepository
+
+<MemberInfo kind="method" type={`(ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a> | undefined, target: ObjectType&#60;Entity&#62; | EntitySchema&#60;Entity&#62; | string, options?: {             replicationMode?: ReplicationMode;         }) => Repository&#60;Entity&#62;`}   />
+
+Returns a TypeORM repository which is bound to any existing transactions. It is recommended to _always_ pass
+the RequestContext argument when possible, otherwise the queries will be executed outside of any
+ongoing transactions which have been started by the <a href='/reference/typescript-api/request/transaction-decorator#transaction'>Transaction</a> decorator.
+
+The `options` parameter allows specifying additional configurations, such as the `replicationMode`,
+which determines whether the repository should interact with the master or replica database.
+### getRepository
+
+<MemberInfo kind="method" type={`(ctxOrTarget: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a> | ObjectType&#60;Entity&#62; | EntitySchema&#60;Entity&#62; | string | undefined, maybeTarget?: ObjectType&#60;Entity&#62; | EntitySchema&#60;Entity&#62; | string, options?: {             replicationMode?: ReplicationMode;         }) => Repository&#60;Entity&#62;`}   />
+
+Returns a TypeORM repository. Depending on the parameters passed, it will either be transaction-aware
+or not. If `RequestContext` is provided, the repository is bound to any ongoing transactions. The
+`options` parameter allows further customization, such as selecting the replication mode (e.g., 'master').
+### withTransaction
+
+<MemberInfo kind="method" type={`(work: (ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>) =&#62; Promise&#60;T&#62;) => Promise&#60;T&#62;`}  since="1.3.0"  />
+
+Allows database operations to be wrapped in a transaction, ensuring that in the event of an error being
+thrown at any point, the entire transaction will be rolled back and no changes will be saved.
+
+In the context of API requests, you should instead use the <a href='/reference/typescript-api/request/transaction-decorator#transaction'>Transaction</a> decorator on your resolver or
+controller method.
+
+On the other hand, for code that does not run in the context of a GraphQL/REST request, this method
+should be used to protect against non-atomic changes to the data which could leave your data in an
+inconsistent state.
+
+Such situations include function processed by the JobQueue or stand-alone scripts which make use
+of Vendure internal services.
+
+If there is already a <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a> object available, you should pass it in as the first
+argument in order to create transactional context as the copy. If not, omit the first argument and an empty
+RequestContext object will be created, which is then used to propagate the transaction to
+all inner method calls.
+
+*Example*
+
+```ts
+private async transferCredit(outerCtx: RequestContext, fromId: ID, toId: ID, amount: number) {
+  await this.connection.withTransaction(outerCtx, async ctx => {
+    // Note you must not use `outerCtx` here, instead use `ctx`. Otherwise, this query
+    // will be executed outside of transaction
+    await this.giftCardService.updateCustomerCredit(ctx, fromId, -amount);
+
+    await this.connection.getRepository(ctx, GiftCard).update(fromId, { transferred: true })
+
+    // If some intermediate logic here throws an Error,
+    // then all DB transactions will be rolled back and neither Customer's
+    // credit balance will have changed.
+
+    await this.giftCardService.updateCustomerCredit(ctx, toId, amount);
+  })
+}
+```
+### withTransaction
+
+<MemberInfo kind="method" type={`(ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>, work: (ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>) =&#62; Promise&#60;T&#62;) => Promise&#60;T&#62;`}   />
+
+
+### withTransaction
+
+<MemberInfo kind="method" type={`(ctxOrWork: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a> | ((ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>) =&#62; Promise&#60;T&#62;), maybeWork?: (ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>) =&#62; Promise&#60;T&#62;) => Promise&#60;T&#62;`}   />
+
+
+### startTransaction
+
+<MemberInfo kind="method" type={`(ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>, isolationLevel?: <a href='/reference/typescript-api/request/transaction-decorator#transactionisolationlevel'>TransactionIsolationLevel</a>) => `}   />
+
+Manually start a transaction if one is not already in progress. This method should be used in
+conjunction with the `'manual'` mode of the <a href='/reference/typescript-api/request/transaction-decorator#transaction'>Transaction</a> decorator.
+### commitOpenTransaction
+
+<MemberInfo kind="method" type={`(ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>) => `}   />
+
+Manually commits any open transaction. Should be very rarely needed, since the <a href='/reference/typescript-api/request/transaction-decorator#transaction'>Transaction</a> decorator
+and the internal TransactionInterceptor take care of this automatically. Use-cases include situations
+in which the worker thread needs to access changes made in the current transaction, or when using the
+Transaction decorator in manual mode.
+### rollBackTransaction
+
+<MemberInfo kind="method" type={`(ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>) => `}   />
+
+Manually rolls back any open transaction. Should be very rarely needed, since the <a href='/reference/typescript-api/request/transaction-decorator#transaction'>Transaction</a> decorator
+and the internal TransactionInterceptor take care of this automatically. Use-cases include when using the
+Transaction decorator in manual mode.
+### getEntityOrThrow
+
+<MemberInfo kind="method" type={`(ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>, entityType: Type&#60;T&#62;, id: <a href='/reference/typescript-api/common/id#id'>ID</a>, options: <a href='/reference/typescript-api/data-access/get-entity-or-throw-options#getentityorthrowoptions'>GetEntityOrThrowOptions</a>&#60;T&#62; = {}) => Promise&#60;T&#62;`}   />
+
+Finds an entity of the given type by ID, or throws an `EntityNotFoundError` if none
+is found.
+### findOneInChannel
+
+<MemberInfo kind="method" type={`(ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>, entity: Type&#60;T&#62;, id: <a href='/reference/typescript-api/common/id#id'>ID</a>, channelId: <a href='/reference/typescript-api/common/id#id'>ID</a>, options: FindOneOptions&#60;T&#62; = {}) => `}   />
+
+Like the TypeOrm `Repository.findOne()` method, but limits the results to
+the given Channel.
+### findByIdsInChannel
+
+<MemberInfo kind="method" type={`(ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>, entity: Type&#60;T&#62;, ids: <a href='/reference/typescript-api/common/id#id'>ID</a>[], channelId: <a href='/reference/typescript-api/common/id#id'>ID</a>, options: FindManyOptions&#60;T&#62;) => `}   />
+
+Like the TypeOrm `Repository.findByIds()` method, but limits the results to
+the given Channel.
+
+
+</div>

package/docs/reference/typescript-api/default-search-plugin/default-search-plugin-init-options.md

@@ -0,0 +1,126 @@
+---
+title: "DefaultSearchPluginInitOptions"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## DefaultSearchPluginInitOptions
+
+<GenerationInfo sourceFile="packages/core/src/plugin/default-search-plugin/types.ts" sourceLine="15" packageName="@vendure/core" />
+
+Options which configure the behaviour of the DefaultSearchPlugin
+
+```ts title="Signature"
+interface DefaultSearchPluginInitOptions {
+    indexStockStatus?: boolean;
+    bufferUpdates?: boolean;
+    searchStrategy?: SearchStrategy;
+}
+```
+
+<div className="members-wrapper">
+
+### indexStockStatus
+
+<MemberInfo kind="property" type={`boolean`} default={`false.`}   />
+
+If set to `true`, the stock status of a ProductVariant (inStock: Boolean) will
+be exposed in the `search` query results. Enabling this option on an existing
+Vendure installation will require a DB migration/synchronization.
+### bufferUpdates
+
+<MemberInfo kind="property" type={`boolean`} default={`false`}  since="1.3.0"  />
+
+If set to `true`, updates to Products, ProductVariants and Collections will not immediately
+trigger an update to the search index. Instead, all these changes will be buffered and will
+only be run via a call to the `runPendingSearchIndexUpdates` mutation in the Admin API.
+
+This is very useful for installations with a large number of ProductVariants and/or
+Collections, as the buffering allows better control over when these expensive jobs are run,
+and also performs optimizations to minimize the amount of work that needs to be performed by
+the worker.
+### searchStrategy
+
+<MemberInfo kind="property" type={`<a href='/reference/typescript-api/default-search-plugin/search-strategy#searchstrategy'>SearchStrategy</a>`} default={`undefined`}  since="1.6.0"  />
+
+Set a custom search strategy that implements <a href='/reference/typescript-api/default-search-plugin/search-strategy#searchstrategy'>SearchStrategy</a> or extends an existing search strategy
+such as <a href='/reference/typescript-api/default-search-plugin/mysql-search-strategy#mysqlsearchstrategy'>MysqlSearchStrategy</a>, <a href='/reference/typescript-api/default-search-plugin/postgres-search-strategy#postgressearchstrategy'>PostgresSearchStrategy</a> or <a href='/reference/typescript-api/default-search-plugin/sqlite-search-strategy#sqlitesearchstrategy'>SqliteSearchStrategy</a>.
+
+*Example*
+
+```ts
+export class MySearchStrategy implements SearchStrategy {
+    private readonly minTermLength = 2;
+    private connection: TransactionalConnection;
+    private options: DefaultSearchPluginInitOptions;
+
+    async init(injector: Injector) {
+        this.connection = injector.get(TransactionalConnection);
+        this.options = injector.get(PLUGIN_INIT_OPTIONS);
+    }
+
+    async getFacetValueIds(
+        ctx: RequestContext,
+        input: SearchInput,
+        enabledOnly: boolean,
+    ): Promise<Map<ID, number>> {
+        // ...
+        return createFacetIdCountMap(facetValuesResult);
+    }
+
+    async getCollectionIds(
+        ctx: RequestContext,
+        input: SearchInput,
+        enabledOnly: boolean,
+    ): Promise<Map<ID, number>> {
+        // ...
+        return createCollectionIdCountMap(collectionsResult);
+    }
+
+    async getSearchResults(
+        ctx: RequestContext,
+        input: SearchInput,
+        enabledOnly: boolean,
+    ): Promise<SearchResult[]> {
+        const take = input.take || 25;
+        const skip = input.skip || 0;
+        const sort = input.sort;
+        const qb = this.connection
+            .getRepository(SearchIndexItem)
+            .createQueryBuilder('si')
+            .select(this.createMysqlSelect(!!input.groupByProduct));
+        // ...
+
+        return qb
+            .take(take)
+            .skip(skip)
+            .getRawMany()
+            .then(res => res.map(r => mapToSearchResult(r, ctx.channel.currencyCode)));
+    }
+
+    async getTotalCount(ctx: RequestContext, input: SearchInput, enabledOnly: boolean): Promise<number> {
+        const innerQb = this.applyTermAndFilters(
+            ctx,
+            this.connection
+                .getRepository(SearchIndexItem)
+                .createQueryBuilder('si')
+                .select(this.createMysqlSelect(!!input.groupByProduct)),
+            input,
+        );
+        if (enabledOnly) {
+            innerQb.andWhere('si.enabled = :enabled', { enabled: true });
+        }
+
+        const totalItemsQb = this.connection.rawConnection
+            .createQueryBuilder()
+            .select('COUNT(*) as total')
+            .from(`(${innerQb.getQuery()})`, 'inner')
+            .setParameters(innerQb.getParameters());
+        return totalItemsQb.getRawOne().then(res => res.total);
+    }
+}
+```
+
+
+</div>

package/docs/reference/typescript-api/default-search-plugin/index.md

@@ -0,0 +1,64 @@
+---
+title: "DefaultSearchPlugin"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## DefaultSearchPlugin
+
+<GenerationInfo sourceFile="packages/core/src/plugin/default-search-plugin/default-search-plugin.ts" sourceLine="70" packageName="@vendure/core" />
+
+The DefaultSearchPlugin provides a full-text Product search based on the full-text searching capabilities of the
+underlying database.
+
+The DefaultSearchPlugin is bundled with the `@vendure/core` package. If you are not using an alternative search
+plugin, then make sure this one is used, otherwise you will not be able to search products via the
+[`search` query](/reference/graphql-api/shop/queries#search).
+
+:::caution
+Note that the quality of the fulltext search capabilities varies depending on the underlying database being used. For example,
+the MySQL & Postgres implementations will typically yield better results than the SQLite implementation.
+:::
+
+*Example*
+
+```ts
+import { DefaultSearchPlugin, VendureConfig } from '@vendure/core';
+
+export const config: VendureConfig = {
+  // Add an instance of the plugin to the plugins array
+  plugins: [
+    DefaultSearchPlugin.init({
+      indexStockStatus: true,
+      bufferUpdates: true,
+    }),
+  ],
+};
+```
+
+```ts title="Signature"
+class DefaultSearchPlugin implements OnApplicationBootstrap, OnApplicationShutdown {
+    static options: DefaultSearchPluginInitOptions = {};
+    init(options: DefaultSearchPluginInitOptions) => Type<DefaultSearchPlugin>;
+}
+```
+* Implements: <code>OnApplicationBootstrap</code>, <code>OnApplicationShutdown</code>
+
+
+
+<div className="members-wrapper">
+
+### options
+
+<MemberInfo kind="property" type={`<a href='/reference/typescript-api/default-search-plugin/default-search-plugin-init-options#defaultsearchplugininitoptions'>DefaultSearchPluginInitOptions</a>`}   />
+
+
+### init
+
+<MemberInfo kind="method" type={`(options: <a href='/reference/typescript-api/default-search-plugin/default-search-plugin-init-options#defaultsearchplugininitoptions'>DefaultSearchPluginInitOptions</a>) => Type&#60;<a href='/reference/typescript-api/default-search-plugin/#defaultsearchplugin'>DefaultSearchPlugin</a>&#62;`}   />
+
+
+
+
+</div>