@vendure/docs 0.0.0-202601161541

package/docs/reference/typescript-api/configuration/collection-filter.md

@@ -0,0 +1,76 @@
+---
+title: "CollectionFilter"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## CollectionFilter
+
+<GenerationInfo sourceFile="packages/core/src/config/catalog/collection-filter.ts" sourceLine="64" packageName="@vendure/core" />
+
+A CollectionFilter defines a rule which can be used to associate ProductVariants with a Collection.
+The filtering is done by defining the `apply()` function, which receives a TypeORM
+[`QueryBuilder`](https://typeorm.io/#/select-query-builder) object to which clauses may be added.
+
+Creating a CollectionFilter is considered an advanced Vendure topic. For more insight into how
+they work, study the [default collection filters](https://github.com/vendurehq/vendure/blob/master/packages/core/src/config/catalog/default-collection-filters.ts)
+
+Here's a simple example of a custom CollectionFilter:
+
+*Example*
+
+```ts
+import { CollectionFilter, LanguageCode } from '@vendure/core';
+
+export const skuCollectionFilter = new CollectionFilter({
+  args: {
+    // The `args` object defines the user-configurable arguments
+    // which will get passed to the filter's `apply()` function.
+    sku: {
+      type: 'string',
+      label: [{ languageCode: LanguageCode.en, value: 'SKU' }],
+      description: [
+        {
+          languageCode: LanguageCode.en,
+          value: 'Matches any product variants with SKUs containing this value',
+        },
+      ],
+    },
+  },
+  code: 'variant-sku-filter',
+  description: [{ languageCode: LanguageCode.en, value: 'Filter by matching SKU' }],
+
+  // This is the function that defines the logic of the filter.
+  apply: (qb, args) => {
+    const LIKE = qb.connection.options.type === 'postgres' ? 'ILIKE' : 'LIKE';
+    return qb.andWhere(`productVariant.sku ${LIKE} :sku`, { sku: `%${args.sku}%` });
+  },
+});
+```
+
+```ts title="Signature"
+class CollectionFilter<T extends ConfigArgs = ConfigArgs> extends ConfigurableOperationDef<T> {
+    constructor(config: CollectionFilterConfig<T>)
+    apply(qb: SelectQueryBuilder<ProductVariant>, args: ConfigArg[]) => SelectQueryBuilder<ProductVariant>;
+}
+```
+* Extends: <code><a href='/reference/typescript-api/configurable-operation-def/#configurableoperationdef'>ConfigurableOperationDef</a>&#60;T&#62;</code>
+
+
+
+<div className="members-wrapper">
+
+### constructor
+
+<MemberInfo kind="method" type={`(config: CollectionFilterConfig&#60;T&#62;) => CollectionFilter`}   />
+
+
+### apply
+
+<MemberInfo kind="method" type={`(qb: SelectQueryBuilder&#60;<a href='/reference/typescript-api/entities/product-variant#productvariant'>ProductVariant</a>&#62;, args: ConfigArg[]) => SelectQueryBuilder&#60;<a href='/reference/typescript-api/entities/product-variant#productvariant'>ProductVariant</a>&#62;`}   />
+
+
+
+
+</div>

package/docs/reference/typescript-api/configuration/default-config.md

@@ -0,0 +1,13 @@
+---
+title: "DefaultConfig"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## defaultConfig
+
+<GenerationInfo sourceFile="packages/core/src/config/default-config.ts" sourceLine="69" packageName="@vendure/core" />
+
+The default configuration settings which are used if not explicitly overridden in the bootstrap() call.
+

package/docs/reference/typescript-api/configuration/default-slug-strategy.md

@@ -0,0 +1,46 @@
+---
+title: "DefaultSlugStrategy"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## DefaultSlugStrategy
+
+<GenerationInfo sourceFile="packages/core/src/config/entity/default-slug-strategy.ts" sourceLine="25" packageName="@vendure/core" since="3.5.0" />
+
+The default strategy for generating slugs. This strategy:
+- Converts to lowercase
+- Replaces spaces and special characters with hyphens
+- Removes non-alphanumeric characters (except hyphens)
+- Removes leading and trailing hyphens
+- Collapses multiple hyphens into one
+
+*Example*
+
+```ts
+const strategy = new DefaultSlugStrategy();
+strategy.generate(ctx, { value: "Hello World!" }); // "hello-world"
+strategy.generate(ctx, { value: "Café Français" }); // "cafe-francais"
+strategy.generate(ctx, { value: "100% Natural" }); // "100-natural"
+```
+
+```ts title="Signature"
+class DefaultSlugStrategy implements SlugStrategy {
+    generate(ctx: RequestContext, params: SlugGenerateParams) => string;
+}
+```
+* Implements: <code><a href='/reference/typescript-api/configuration/slug-strategy#slugstrategy'>SlugStrategy</a></code>
+
+
+
+<div className="members-wrapper">
+
+### generate
+
+<MemberInfo kind="method" type={`(ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>, params: SlugGenerateParams) => string`}   />
+
+
+
+
+</div>

package/docs/reference/typescript-api/configuration/entity-duplicator.md

@@ -0,0 +1,195 @@
+---
+title: "EntityDuplicator"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## EntityDuplicator
+
+<GenerationInfo sourceFile="packages/core/src/config/entity/entity-duplicator.ts" sourceLine="158" packageName="@vendure/core" since="2.2.0" />
+
+An EntityDuplicator is used to define the logic for duplicating entities when the `duplicateEntity` mutation is called.
+This allows you to add support for duplication of both core and custom entities.
+
+*Example*
+
+```ts title=src/config/custom-collection-duplicator.ts
+import { Collection, LanguageCode, Permission
+  EntityDuplicator, TransactionalConnection, CollectionService } from '@vendure/core';
+
+let collectionService: CollectionService;
+let connection: TransactionalConnection;
+
+// This is just an example - we already ship with a built-in duplicator for Collections.
+const customCollectionDuplicator = new EntityDuplicator({
+    code: 'custom-collection-duplicator',
+    description: [{ languageCode: LanguageCode.en, value: 'Custom collection duplicator' }],
+    args: {
+        throwError: {
+            type: 'boolean',
+            defaultValue: false,
+        },
+    },
+    forEntities: ['Collection'],
+    requiresPermission: [Permission.UpdateCollection],
+    init(injector) {
+        collectionService = injector.get(CollectionService);
+        connection = injector.get(TransactionalConnection);
+    },
+    duplicate: async input => {
+        const { ctx, id, args } = input;
+
+        const original = await connection.getEntityOrThrow(ctx, Collection, id, {
+            relations: {
+                assets: true,
+                featuredAsset: true,
+            },
+        });
+        const newCollection = await collectionService.create(ctx, {
+            isPrivate: original.isPrivate,
+            customFields: original.customFields,
+            assetIds: original.assets.map(a => a.id),
+            featuredAssetId: original.featuredAsset?.id,
+            parentId: original.parentId,
+            filters: original.filters.map(f => ({
+                code: f.code,
+                arguments: f.args,
+            })),
+            inheritFilters: original.inheritFilters,
+            translations: original.translations.map(t => ({
+                languageCode: t.languageCode,
+                name: `${t.name} (copy)`,
+                slug: `${t.slug}-copy`,
+                description: t.description,
+                customFields: t.customFields,
+            })),
+        });
+
+        if (args.throwError) {
+            // If an error is thrown at any point during the duplication process, the entire
+            // transaction will get automatically rolled back, and the mutation will return
+            // an ErrorResponse containing the error message.
+            throw new Error('Dummy error');
+        }
+
+        return newCollection;
+    },
+});
+```
+
+The duplicator then gets passed to your VendureConfig object:
+
+```ts title=src/vendure-config.ts
+import { VendureConfig, defaultEntityDuplicators } from '@vendure/core';
+import { customCollectionDuplicator } from './config/custom-collection-duplicator';
+
+export const config: VendureConfig = {
+   // ...
+   entityOptions: {
+     entityDuplicators: [
+         ...defaultEntityDuplicators,
+         customCollectionDuplicator,
+     ],
+   },
+};
+```
+
+```ts title="Signature"
+class EntityDuplicator<T extends ConfigArgs = ConfigArgs> extends ConfigurableOperationDef<T> {
+    constructor(config: EntityDuplicatorConfig<T>)
+    duplicate(input: {
+        ctx: RequestContext;
+        entityName: string;
+        id: ID;
+        args: ConfigArg[];
+    }) => Promise<VendureEntity>;
+}
+```
+* Extends: <code><a href='/reference/typescript-api/configurable-operation-def/#configurableoperationdef'>ConfigurableOperationDef</a>&#60;T&#62;</code>
+
+
+
+<div className="members-wrapper">
+
+### constructor
+
+<MemberInfo kind="method" type={`(config: <a href='/reference/typescript-api/configuration/entity-duplicator#entityduplicatorconfig'>EntityDuplicatorConfig</a>&#60;T&#62;) => EntityDuplicator`}   />
+
+
+### duplicate
+
+<MemberInfo kind="method" type={`(input: {         ctx: <a href='/reference/typescript-api/request/request-context#requestcontext'>RequestContext</a>;         entityName: string;         id: <a href='/reference/typescript-api/common/id#id'>ID</a>;         args: ConfigArg[];     }) => Promise&#60;<a href='/reference/typescript-api/entities/vendure-entity#vendureentity'>VendureEntity</a>&#62;`}   />
+
+
+
+
+</div>
+
+
+## DuplicateEntityFn
+
+<GenerationInfo sourceFile="packages/core/src/config/entity/entity-duplicator.ts" sourceLine="21" packageName="@vendure/core" since="2.2.0" />
+
+A function which performs the duplication of an entity.
+
+```ts title="Signature"
+type DuplicateEntityFn<T extends ConfigArgs> = (input: {
+    ctx: RequestContext;
+    entityName: string;
+    id: ID;
+    args: ConfigArgValues<T>;
+}) => Promise<VendureEntity>
+```
+
+
+## EntityDuplicatorConfig
+
+<GenerationInfo sourceFile="packages/core/src/config/entity/entity-duplicator.ts" sourceLine="36" packageName="@vendure/core" since="2.2.0" />
+
+Configuration for creating a new EntityDuplicator.
+
+```ts title="Signature"
+interface EntityDuplicatorConfig<T extends ConfigArgs> extends ConfigurableOperationDefOptions<T> {
+    requiresPermission: Array<Permission | string> | Permission | string;
+    forEntities: string[];
+    duplicate: DuplicateEntityFn<T>;
+}
+```
+* Extends: <code><a href='/reference/typescript-api/configurable-operation-def/configurable-operation-def-options#configurableoperationdefoptions'>ConfigurableOperationDefOptions</a>&#60;T&#62;</code>
+
+
+
+<div className="members-wrapper">
+
+### requiresPermission
+
+<MemberInfo kind="property" type={`Array&#60;<a href='/reference/typescript-api/common/permission#permission'>Permission</a> | string&#62; | <a href='/reference/typescript-api/common/permission#permission'>Permission</a> | string`}   />
+
+The permissions required in order to execute this duplicator. If an array is passed,
+then the administrator must have at least one of the permissions in the array.
+### forEntities
+
+<MemberInfo kind="property" type={`string[]`}   />
+
+The entities for which this duplicator is able to duplicate.
+### duplicate
+
+<MemberInfo kind="property" type={`<a href='/reference/typescript-api/configuration/entity-duplicator#duplicateentityfn'>DuplicateEntityFn</a>&#60;T&#62;`}   />
+
+The function which performs the duplication.
+
+*Example*
+
+```ts
+duplicate: async input => {
+  const { ctx, id, args } = input;
+
+  // perform the duplication logic here
+
+  return newEntity;
+}
+```
+
+
+</div>

package/docs/reference/typescript-api/configuration/entity-id-decorator.md

@@ -0,0 +1,24 @@
+---
+title: "EntityId Decorator"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## EntityId
+
+<GenerationInfo sourceFile="packages/core/src/entity/entity-id.decorator.ts" sourceLine="41" packageName="@vendure/core" />
+
+Decorates a property which points to another entity by ID. This custom decorator is needed
+because we do not know the data type of the ID column until runtime, when we have access
+to the configured EntityIdStrategy.
+
+```ts title="Signature"
+function EntityId(options?: IdColumnOptions): void
+```
+Parameters
+
+### options
+
+<MemberInfo kind="parameter" type={`IdColumnOptions`} />
+

package/docs/reference/typescript-api/configuration/entity-id-strategy.md

@@ -0,0 +1,168 @@
+---
+title: "EntityIdStrategy"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## AutoIncrementIdStrategy
+
+<GenerationInfo sourceFile="packages/core/src/config/entity/auto-increment-id-strategy.ts" sourceLine="11" packageName="@vendure/core" />
+
+An id strategy which uses auto-increment integers as primary keys
+for all entities. This is the default strategy used by Vendure.
+
+```ts title="Signature"
+class AutoIncrementIdStrategy implements EntityIdStrategy<'increment'> {
+    readonly primaryKeyType = 'increment';
+    decodeId(id: string) => number;
+    encodeId(primaryKey: number) => string;
+}
+```
+* Implements: <code><a href='/reference/typescript-api/configuration/entity-id-strategy#entityidstrategy'>EntityIdStrategy</a>&#60;'increment'&#62;</code>
+
+
+
+<div className="members-wrapper">
+
+### primaryKeyType
+
+<MemberInfo kind="property" type={``}   />
+
+
+### decodeId
+
+<MemberInfo kind="method" type={`(id: string) => number`}   />
+
+
+### encodeId
+
+<MemberInfo kind="method" type={`(primaryKey: number) => string`}   />
+
+
+
+
+</div>
+
+
+## EntityIdStrategy
+
+<GenerationInfo sourceFile="packages/core/src/config/entity/entity-id-strategy.ts" sourceLine="32" packageName="@vendure/core" />
+
+The EntityIdStrategy determines how entity IDs are generated and stored in the
+database, as well as how they are transformed when being passed from the API to the
+service layer and vice versa.
+
+Vendure ships with two strategies: <a href='/reference/typescript-api/configuration/entity-id-strategy#autoincrementidstrategy'>AutoIncrementIdStrategy</a> and <a href='/reference/typescript-api/configuration/entity-id-strategy#uuididstrategy'>UuidIdStrategy</a>,
+but custom strategies can be used, e.g. to apply some custom encoding to the ID before exposing
+it in the GraphQL API.
+
+:::info
+
+This is configured via the `entityOptions.entityIdStrategy` property of
+your VendureConfig.
+
+:::
+
+:::caution
+Note: changing from an integer-based strategy to a uuid-based strategy
+on an existing Vendure database will lead to problems with broken foreign-key
+references. To change primary key types like this, you'll need to start with
+a fresh database.
+:::
+
+```ts title="Signature"
+interface EntityIdStrategy<T extends 'increment' | 'uuid'> extends InjectableStrategy {
+    readonly primaryKeyType: T;
+    encodeId: (primaryKey: PrimaryKeyType<T>) => string;
+    decodeId: (id: string) => PrimaryKeyType<T>;
+}
+```
+* Extends: <code><a href='/reference/typescript-api/common/injectable-strategy#injectablestrategy'>InjectableStrategy</a></code>
+
+
+
+<div className="members-wrapper">
+
+### primaryKeyType
+
+<MemberInfo kind="property" type={`T`}   />
+
+Defines how the primary key will be stored in the database - either
+`'increment'` for auto-increment integer IDs, or `'uuid'` for a unique
+string ID.
+### encodeId
+
+<MemberInfo kind="property" type={`(primaryKey: PrimaryKeyType&#60;T&#62;) =&#62; string`}   />
+
+Allows the raw ID from the database to be transformed in some way before exposing
+it in the GraphQL API.
+
+For example, you may need to use auto-increment integer IDs due to some business
+constraint, but you may not want to expose this data publicly in your API. In this
+case, you can use the encode/decode methods to obfuscate the ID with some kind of
+encoding scheme, such as base64 (or something more sophisticated).
+### decodeId
+
+<MemberInfo kind="property" type={`(id: string) =&#62; PrimaryKeyType&#60;T&#62;`}   />
+
+Reverses the transformation performed by the `encodeId` method in order to get
+back to the raw ID value.
+
+
+</div>
+
+
+## UuidIdStrategy
+
+<GenerationInfo sourceFile="packages/core/src/config/entity/uuid-id-strategy.ts" sourceLine="25" packageName="@vendure/core" />
+
+An id strategy which uses string uuids as primary keys
+for all entities. This strategy can be configured with the
+`entityIdStrategy` property of the `entityOptions` property
+of <a href='/reference/typescript-api/configuration/vendure-config#vendureconfig'>VendureConfig</a>.
+
+*Example*
+
+```ts
+import { UuidIdStrategy, VendureConfig } from '@vendure/core';
+
+export const config: VendureConfig = {
+  entityOptions: {
+    entityIdStrategy: new UuidIdStrategy(),
+    // ...
+  }
+}
+```
+
+```ts title="Signature"
+class UuidIdStrategy implements EntityIdStrategy<'uuid'> {
+    readonly primaryKeyType = 'uuid';
+    decodeId(id: string) => string;
+    encodeId(primaryKey: string) => string;
+}
+```
+* Implements: <code><a href='/reference/typescript-api/configuration/entity-id-strategy#entityidstrategy'>EntityIdStrategy</a>&#60;'uuid'&#62;</code>
+
+
+
+<div className="members-wrapper">
+
+### primaryKeyType
+
+<MemberInfo kind="property" type={``}   />
+
+
+### decodeId
+
+<MemberInfo kind="method" type={`(id: string) => string`}   />
+
+
+### encodeId
+
+<MemberInfo kind="method" type={`(primaryKey: string) => string`}   />
+
+
+
+
+</div>

package/docs/reference/typescript-api/configuration/entity-options.md

@@ -0,0 +1,153 @@
+---
+title: "EntityOptions"
+generated: true
+---
+<!-- This file was generated from the Vendure source. Do not modify. Instead, re-run the "docs:build" script -->
+
+
+## EntityOptions
+
+<GenerationInfo sourceFile="packages/core/src/config/vendure-config.ts" sourceLine="1036" packageName="@vendure/core" since="1.3.0" />
+
+Options relating to the internal handling of entities.
+
+```ts title="Signature"
+interface EntityOptions {
+    entityIdStrategy?: EntityIdStrategy<any>;
+    entityDuplicators?: Array<EntityDuplicator<any>>;
+    moneyStrategy?: MoneyStrategy;
+    channelCacheTtl?: number;
+    zoneCacheTtl?: number;
+    taxRateCacheTtl?: number;
+    metadataModifiers?: EntityMetadataModifier[];
+    slugStrategy?: SlugStrategy;
+}
+```
+
+<div className="members-wrapper">
+
+### entityIdStrategy
+
+<MemberInfo kind="property" type={`<a href='/reference/typescript-api/configuration/entity-id-strategy#entityidstrategy'>EntityIdStrategy</a>&#60;any&#62;`} default={`<a href='/reference/typescript-api/configuration/entity-id-strategy#autoincrementidstrategy'>AutoIncrementIdStrategy</a>`}  since="1.3.0"  />
+
+Defines the strategy used for both storing the primary keys of entities
+in the database, and the encoding & decoding of those ids when exposing
+entities via the API. The default uses a simple auto-increment integer
+strategy.
+
+:::caution
+Note: changing from an integer-based strategy to a uuid-based strategy
+on an existing Vendure database will lead to problems with broken foreign-key
+references. To change primary key types like this, you'll need to start with
+a fresh database.
+:::
+### entityDuplicators
+
+<MemberInfo kind="property" type={`Array&#60;<a href='/reference/typescript-api/configuration/entity-duplicator#entityduplicator'>EntityDuplicator</a>&#60;any&#62;&#62;`} default={`defaultEntityDuplicators`}  since="2.2.0"  />
+
+An array of <a href='/reference/typescript-api/configuration/entity-duplicator#entityduplicator'>EntityDuplicator</a> instances which are used to duplicate entities
+when using the `duplicateEntity` mutation.
+### moneyStrategy
+
+<MemberInfo kind="property" type={`<a href='/reference/typescript-api/money/money-strategy#moneystrategy'>MoneyStrategy</a>`} default={`<a href='/reference/typescript-api/money/default-money-strategy#defaultmoneystrategy'>DefaultMoneyStrategy</a>`}  since="2.0.0"  />
+
+Defines the strategy used to store and round monetary values.
+### channelCacheTtl
+
+<MemberInfo kind="property" type={`number`} default={`30000`}  since="1.3.0"  />
+
+Channels get cached in-memory as they are accessed very frequently. This
+setting determines how long the cache lives (in ms) until it is considered stale and
+refreshed. For multi-instance deployments (e.g. serverless, load-balanced), a
+smaller value here will prevent data inconsistencies between instances.
+### zoneCacheTtl
+
+<MemberInfo kind="property" type={`number`} default={`30000`}  since="1.3.0"  />
+
+Zones get cached in-memory as they are accessed very frequently. This
+setting determines how long the cache lives (in ms) until it is considered stale and
+refreshed. For multi-instance deployments (e.g. serverless, load-balanced), a
+smaller value here will prevent data inconsistencies between instances.
+### taxRateCacheTtl
+
+<MemberInfo kind="property" type={`number`} default={`30000`}  since="1.9.0"  />
+
+TaxRates get cached in-memory as they are accessed very frequently. This
+setting determines how long the cache lives (in ms) until it is considered stale and
+refreshed. For multi-instance deployments (e.g. serverless, load-balanced), a
+smaller value here will prevent data inconsistencies between instances.
+### metadataModifiers
+
+<MemberInfo kind="property" type={`<a href='/reference/typescript-api/configuration/entity-options#entitymetadatamodifier'>EntityMetadataModifier</a>[]`} default={`[]`}  since="1.6.0"  />
+
+Allows the metadata of the built-in TypeORM entities to be manipulated. This allows you
+to do things like altering data types, adding indices etc. This is an advanced feature
+which should be used with some caution as it will result in DB schema changes. For examples
+see <a href='/reference/typescript-api/configuration/entity-options#entitymetadatamodifier'>EntityMetadataModifier</a>.
+### slugStrategy
+
+<MemberInfo kind="property" type={`<a href='/reference/typescript-api/configuration/slug-strategy#slugstrategy'>SlugStrategy</a>`} default={`<a href='/reference/typescript-api/configuration/default-slug-strategy#defaultslugstrategy'>DefaultSlugStrategy</a>`}  since="3.5.0"  />
+
+Defines the strategy for generating slugs from input strings.
+Slugs are URL-friendly versions of text commonly used for entity identifiers in URLs.
+
+
+</div>
+
+
+## EntityMetadataModifier
+
+<GenerationInfo sourceFile="packages/core/src/config/entity-metadata/entity-metadata-modifier.ts" sourceLine="56" packageName="@vendure/core" since="1.6.0" />
+
+A function which allows TypeORM entity metadata to be manipulated prior to the DB schema being generated
+during bootstrap.
+
+:::caution
+Certain DB schema modifications will result in auto-generated migrations which will lead to data loss. For instance,
+changing the data type of a column will drop the column & data and then re-create it. To avoid loss of important data,
+always check and modify your migration scripts as needed.
+:::
+
+*Example*
+
+```ts
+import { Index } from 'typeorm';
+import { EntityMetadataModifier, ProductVariant } from '@vendure/core';
+
+// Adds a unique index to the ProductVariant.sku column
+export const addSkuUniqueIndex: EntityMetadataModifier = metadata => {
+  const instance = new ProductVariant();
+  Index({ unique: true })(instance, 'sku');
+};
+```
+
+*Example*
+
+```ts
+import { Column } from 'typeorm';
+import { EntityMetadataModifier, ProductTranslation } from '@vendure/core';
+
+// Use the "mediumtext" datatype for the Product's description rather than
+// the default "text" type.
+export const makeProductDescriptionMediumText: EntityMetadataModifier = metadata => {
+    const descriptionColumnIndex = metadata.columns.findIndex(
+        col => col.propertyName === 'description' && col.target === ProductTranslation,
+    );
+    if (-1 < descriptionColumnIndex) {
+        // First we need to remove the existing column definition
+        // from the metadata.
+        metadata.columns.splice(descriptionColumnIndex, 1);
+        // Then we add a new column definition with our custom
+        // data type "mediumtext"
+        // DANGER: this particular modification will generate a DB migration
+        // which will result in data loss of existing descriptions. Make sure
+        // to manually check & modify your migration scripts.
+        const instance = new ProductTranslation();
+        Column({ type: 'mediumtext' })(instance, 'description');
+    }
+};
+```
+
+```ts title="Signature"
+type EntityMetadataModifier = (metadata: MetadataArgsStorage) => void | Promise<void>
+```

package/docs/reference/typescript-api/configuration/index.md

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