Class CollectionCustomizer<S, N>

constructor

• new CollectionCustomizer<
      S extends TSchema = TSchema,
      N extends string = TCollectionName<S>,
  >(
      dataSourceCustomizer: DataSourceCustomizer<S>,
      stack: DecoratorsStackBase,
      name: string,
  ): CollectionCustomizer<S, N>

  Type Parameters

  • S extends TSchema = TSchema
  • N extends string = TCollectionName<S>

  Parameters

  • dataSourceCustomizer: DataSourceCustomizer<S>
  • stack: DecoratorsStackBase
  • name: string

  Returns CollectionCustomizer<S, N>

addField

.addField('fullName', {
   columnType: 'String',
   dependencies: ['firstName', 'lastName'],
   getValues: (records) => records.map(record => `${record.lastName} ${record.firstName}`),
});
Copy

Readonlyname

schema

• get schema(): CollectionSchema

  Returns CollectionSchema

addAction

• addAction(name: string, definition: ActionDefinition<S, N>): this

  Add a new action on the collection.

  Parameters

  • name: string

    the name of the action

  • definition: ActionDefinition<S, N>

    the definition of the action

  Returns this

  See

  Documentation Link

  Example

  .addAction('is live', {
     scope: 'Single',
     execute: async (context, resultBuilder) => {
       return resultBuilder.success('Is live!');
     },
   })
  Copy

addChart

• addChart(name: string, definition: CollectionChartDefinition<S, N>): this

  Create a new API chart

  Parameters

  • name: string

    name of the chart

  • definition: CollectionChartDefinition<S, N>

    definition of the chart

  Returns this

  See

  Documentation Link

  Example

  .addChart('numCustomers', (context, resultBuilder) => {
    return resultBuilder.distribution({
      tomatoes: 10,
      potatoes: 20,
      carrots: 30,
    });
  })
  Copy

addExternalRelation

• addExternalRelation(
      name: string,
      definition: OneToManyEmbeddedDefinition<S, N>,
  ): this

  Add a virtual collection into the related data of a record.

  Parameters

  • name: string

    name of the relation

  • definition: OneToManyEmbeddedDefinition<S, N>

    the definition of the new relation

  Returns this

  See

  Documentation Link

  Example

  .addExternalRelation('states', {
    schema: { code: 'Number', name: 'String' },
    listRecords: ({ id }) => {
      return record.id == 34 ?
       [{ code: 'AL', name: 'Alabama' }, { code: 'AK', name: 'Alaska' }] :
       [{ code: 'AZ', name: 'Arizona' }, { code: 'TX', name: 'Texas' }];
    }
  })
  Copy

addFieldValidation

• addFieldValidation(
      name: Extract<keyof S[N]["plain"], string>,
      operator:
          | "Equal"
          | "NotEqual"
          | "LessThan"
          | "GreaterThan"
          | "LessThanOrEqual"
          | "GreaterThanOrEqual"
          | "Match"
          | "NotContains"
          | "NotIContains"
          | "LongerThan"
          | "ShorterThan"
          | "IncludesAll"
          | "IncludesNone"
          | "Today"
          | "Yesterday"
          | "PreviousMonth"
          | "PreviousQuarter"
          | "PreviousWeek"
          | "PreviousYear"
          | "PreviousMonthToDate"
          | "PreviousQuarterToDate"
          | "PreviousWeekToDate"
          | "PreviousXDaysToDate"
          | "PreviousXDays"
          | "PreviousYearToDate"
          | "Present"
          | "Blank"
          | "Missing"
          | "In"
          | "NotIn"
          | "StartsWith"
          | "EndsWith"
          | "Contains"
          | "IStartsWith"
          | "IEndsWith"
          | "IContains"
          | "Like"
          | "ILike"
          | "Before"
          | "After"
          | "AfterXHoursAgo"
          | "BeforeXHoursAgo"
          | "Future"
          | "Past",
      value?: unknown,
  ): this

  Add a new validator to the edition form of a given field

  Parameters

  • name: Extract<keyof S[N]["plain"], string>

    The name of the field

  • operator:
        | "Equal"
        | "NotEqual"
        | "LessThan"
        | "GreaterThan"
        | "LessThanOrEqual"
        | "GreaterThanOrEqual"
        | "Match"
        | "NotContains"
        | "NotIContains"
        | "LongerThan"
        | "ShorterThan"
        | "IncludesAll"
        | "IncludesNone"
        | "Today"
        | "Yesterday"
        | "PreviousMonth"
        | "PreviousQuarter"
        | "PreviousWeek"
        | "PreviousYear"
        | "PreviousMonthToDate"
        | "PreviousQuarterToDate"
        | "PreviousWeekToDate"
        | "PreviousXDaysToDate"
        | "PreviousXDays"
        | "PreviousYearToDate"
        | "Present"
        | "Blank"
        | "Missing"
        | "In"
        | "NotIn"
        | "StartsWith"
        | "EndsWith"
        | "Contains"
        | "IStartsWith"
        | "IEndsWith"
        | "IContains"
        | "Like"
        | "ILike"
        | "Before"
        | "After"
        | "AfterXHoursAgo"
        | "BeforeXHoursAgo"
        | "Future"
        | "Past"

    The validator that you wish to add

  • Optionalvalue: unknown

    A configuration value that the validator may need

  Returns this

  See

  Documentation Link

  Example

  .addFieldValidation('firstName', 'LongerThan', 2);
  Copy

addHook

• addHook<P extends HookPosition, T extends HookType>(
      position: P,
      type: T,
      handler: HookHandler<HooksContext<S, N>[P][T]>,
  ): this

  Add a new hook handler to an action

  Type Parameters

  • P extends HookPosition
  • T extends HookType

  Parameters

  • position: P

    Either if the hook is executed before or after the action

  • type: T

    Type of action which should be hooked

  • handler: HookHandler<HooksContext<S, N>[P][T]>

    Callback that should be executed when the hook is triggered

  Returns this

  See

  Documentation Link

  Example

  .addHook('Before', 'List', async (context) => {
    // Do something before the list action
  });
  Copy

addManyToManyRelation

• addManyToManyRelation<Foreign extends string, Through extends string>(
      name: string,
      foreignCollection: Foreign,
      throughCollection: Through,
      options: {
          foreignKey: Extract<keyof S[Through]["plain"], string>;
          foreignKeyTarget?: Extract<keyof S[Foreign]["plain"], string>;
          originKey: Extract<keyof S[Through]["plain"], string>;
          originKeyTarget?: Extract<keyof S[N]["plain"], string>;
      },
  ): this

  Add a many to many relation to the collection

  Type Parameters

  • Foreign extends string
  • Through extends string

  Parameters

  • name: string

    name of the new relation

  • foreignCollection: Foreign

    name of the targeted collection

  • throughCollection: Through

    name of the intermediary collection

  • options: {
        foreignKey: Extract<keyof S[Through]["plain"], string>;
        foreignKeyTarget?: Extract<keyof S[Foreign]["plain"], string>;
        originKey: Extract<keyof S[Through]["plain"], string>;
        originKeyTarget?: Extract<keyof S[N]["plain"], string>;
    }

    extra information about the relation

  Returns this

  See

  Documentation Link

  Example

  dvds.addManyToManyRelation('rentalsOfThisDvd', 'rentals', 'dvdRentals', {
    originKey: 'dvdId',
    foreignKey: 'rentalId'
  })
  Copy

addManyToOneRelation

• addManyToOneRelation<T extends string>(
      name: string,
      foreignCollection: T,
      options: {
          foreignKey: Extract<keyof S[N]["plain"], string>;
          foreignKeyTarget?: Extract<keyof S[T]["plain"], string>;
      },
  ): this

  Add a many to one relation to the collection

  Type Parameters

  • T extends string

  Parameters

  • name: string

    name of the new relation

  • foreignCollection: T

    name of the targeted collection

  • options: {
        foreignKey: Extract<keyof S[N]["plain"], string>;
        foreignKeyTarget?: Extract<keyof S[T]["plain"], string>;
    }

    extra information about the relation

  Returns this

  See

  Documentation Link

  Example

  books.addManyToOneRelation('myAuthor', 'persons', { foreignKey: 'authorId' })
  Copy

addOneToManyRelation

• addOneToManyRelation<T extends string>(
      name: string,
      foreignCollection: T,
      options: {
          originKey: Extract<keyof S[T]["plain"], string>;
          originKeyTarget?: Extract<keyof S[N]["plain"], string>;
      },
  ): this

  Add a one to many relation to the collection

  Type Parameters

  • T extends string

  Parameters

  • name: string

    name of the new relation

  • foreignCollection: T

    name of the targeted collection

  • options: {
        originKey: Extract<keyof S[T]["plain"], string>;
        originKeyTarget?: Extract<keyof S[N]["plain"], string>;
    }

    extra information about the relation

  Returns this

  See

  Documentation Link

  Example

  persons.addOneToManyRelation('writtenBooks', 'books', { originKey: 'authorId' })
  Copy

addOneToOneRelation

• addOneToOneRelation<T extends string>(
      name: string,
      foreignCollection: T,
      options: {
          originKey: Extract<keyof S[T]["plain"], string>;
          originKeyTarget?: Extract<keyof S[N]["plain"], string>;
      },
  ): this

  Add a one to one relation to the collection

  Type Parameters

  • T extends string

  Parameters

  • name: string

    name of the new relation

  • foreignCollection: T

    name of the targeted collection

  • options: {
        originKey: Extract<keyof S[T]["plain"], string>;
        originKeyTarget?: Extract<keyof S[N]["plain"], string>;
    }

    extra information about the relation

  Returns this

  See

  Documentation Link

  Example

  persons.addOneToOneRelation('bestFriend', 'persons', { originKey: 'bestFriendId' })
  Copy

addSegment

• addSegment(name: string, definition: SegmentDefinition<S, N>): this

  Add a new segment on the collection.

  Parameters

  • name: string

    the name of the segment

  • definition: SegmentDefinition<S, N>

    a function used to generate a condition tree or a condition tree

  Returns this

  See

  Documentation Link

  Example

  .addSegment(
     'Wrote more than 2 books',
     { field: 'booksCount', operator: 'GreaterThan', value: 2 }
  );
  Copy

disableCount

• disableCount(): this

  Disable count in list view pagination for improved performance.

  Returns this

  Example

  .disableCount()
  Copy

disableFieldSorting

• disableFieldSorting(name: Extract<keyof S[N]["plain"], string>): this

  Disable sorting on a specific field.

  Parameters

  • name: Extract<keyof S[N]["plain"], string>

    the name of the field with sorting to be disabled

  Returns this

  See

  Documentation Link

  Example

  .disableFieldSorting('fullName');
  Copy

disableSearch

• disableSearch(): this

  Disable search on the collection

  Returns this

  Example

  .disableSearch()
  Copy

emulateFieldFiltering

• emulateFieldFiltering(name: Extract<keyof S[N]["plain"], string>): this

  Enable filtering on a specific field using emulation. As for all the emulation method, the field filtering will be done in-memory.

  Parameters

  • name: Extract<keyof S[N]["plain"], string>

    the name of the field to enable emulation on

  Returns this

  See

  Documentation Link

  Example

  .emulateFieldFiltering('aField');
  Copy

emulateFieldOperator

• emulateFieldOperator(
      name: Extract<keyof S[N]["plain"], string>,
      operator:
          | "Equal"
          | "NotEqual"
          | "LessThan"
          | "GreaterThan"
          | "LessThanOrEqual"
          | "GreaterThanOrEqual"
          | "Match"
          | "NotContains"
          | "NotIContains"
          | "LongerThan"
          | "ShorterThan"
          | "IncludesAll"
          | "IncludesNone"
          | "Today"
          | "Yesterday"
          | "PreviousMonth"
          | "PreviousQuarter"
          | "PreviousWeek"
          | "PreviousYear"
          | "PreviousMonthToDate"
          | "PreviousQuarterToDate"
          | "PreviousWeekToDate"
          | "PreviousXDaysToDate"
          | "PreviousXDays"
          | "PreviousYearToDate"
          | "Present"
          | "Blank"
          | "Missing"
          | "In"
          | "NotIn"
          | "StartsWith"
          | "EndsWith"
          | "Contains"
          | "IStartsWith"
          | "IEndsWith"
          | "IContains"
          | "Like"
          | "ILike"
          | "Before"
          | "After"
          | "AfterXHoursAgo"
          | "BeforeXHoursAgo"
          | "Future"
          | "Past",
  ): this

  Enable filtering on a specific field with a specific operator using emulation. As for all the emulation method, the field filtering will be done in-memory.

  Parameters

  • name: Extract<keyof S[N]["plain"], string>

    the name of the field to enable emulation on

  • operator:
        | "Equal"
        | "NotEqual"
        | "LessThan"
        | "GreaterThan"
        | "LessThanOrEqual"
        | "GreaterThanOrEqual"
        | "Match"
        | "NotContains"
        | "NotIContains"
        | "LongerThan"
        | "ShorterThan"
        | "IncludesAll"
        | "IncludesNone"
        | "Today"
        | "Yesterday"
        | "PreviousMonth"
        | "PreviousQuarter"
        | "PreviousWeek"
        | "PreviousYear"
        | "PreviousMonthToDate"
        | "PreviousQuarterToDate"
        | "PreviousWeekToDate"
        | "PreviousXDaysToDate"
        | "PreviousXDays"
        | "PreviousYearToDate"
        | "Present"
        | "Blank"
        | "Missing"
        | "In"
        | "NotIn"
        | "StartsWith"
        | "EndsWith"
        | "Contains"
        | "IStartsWith"
        | "IEndsWith"
        | "IContains"
        | "Like"
        | "ILike"
        | "Before"
        | "After"
        | "AfterXHoursAgo"
        | "BeforeXHoursAgo"
        | "Future"
        | "Past"

    the operator to emulate

  Returns this

  See

  Documentation Link

  Example

  .emulateFieldOperator('aField', 'In');
  Copy

emulateFieldSorting

• emulateFieldSorting(name: Extract<keyof S[N]["plain"], string>): this

  Enable sorting on a specific field using emulation. As for all the emulation method, the field sorting will be done in-memory.

  Parameters

  • name: Extract<keyof S[N]["plain"], string>

    the name of the field to enable emulation on

  Returns this

  See

  Documentation Link

  Example

  .emulateFieldSorting('fullName');
  Copy

importField

• importField(
      name: string,
      options: { path: TFieldName<S, N>; readonly?: boolean },
  ): this

  Import a field from a many to one or one to one relation.

  Parameters

  • name: string

    the name of the field that will be created on the collection

  • options: { path: TFieldName<S, N>; readonly?: boolean }

    options to import the field

  Returns this

  See

  Documentation Link

  Example

  .importField('authorName', { path: 'author:fullName' })
  Copy

overrideCreate

• overrideCreate(handler: CreateOverrideHandler<S, N>): this

  Replace the default create operation

  Parameters

  • handler: CreateOverrideHandler<S, N>

    the new behavior for the create operation

  Returns this

  See

  Documentation Link

  Example

  .overrideCreate(async (context) => {
    const { data } = context;
    const record = await createRecord(data);
    return [record];
  });
  Copy

overrideDelete

• overrideDelete(handler: DeleteOverrideHandler<S, N>): this

  Replace the default delete operation

  Parameters

  • handler: DeleteOverrideHandler<S, N>

    the new behavior for the delete operation

  Returns this

  See

  Documentation Link

  Example

  .overrideDelete(async (context) => {
    const { filter } = context;
    await deleteRecord(filter);
  });
  Copy

overrideUpdate

• overrideUpdate(handler: UpdateOverrideHandler<S, N>): this

  Replace the default update operation

  Parameters

  • handler: UpdateOverrideHandler<S, N>

    the new behavior for the update operation

  Returns this

  See

  Documentation Link

  Example

  .overrideUpdate(async (context) => {
    const { filter, patch } = context;
    await updateRecord(filter, patch);
  });
  Copy

removeField

• removeField(...names: TColumnNameAndRelationName<S, N>[]): this

  Remove fields from the exported schema (they will still be usable within the agent).

  Parameters

  • ...names: TColumnNameAndRelationName<S, N>[]

    the names of the field or the relation

  Returns this

  See

  Documentation Link

  Example

  .removeField('fieldNameToRemove', 'relationNameToRemove');
  Copy

renameField

• renameField(
      currentName: TColumnNameAndRelationName<S, N>,
      newName: string,
  ): this

  Rename fields from the exported schema.

  Parameters

  • currentName: TColumnNameAndRelationName<S, N>

    the current name of the field or the relation in a given collection

  • newName: string

    the new name of the field or the relation

  Returns this

  See

  Documentation Link

  Example

  .renameField('currentFieldOrRelationName', 'newFieldOrRelationName')
  Copy

replaceFieldBinaryMode

• replaceFieldBinaryMode(
      name: Extract<keyof S[N]["plain"], string>,
      binaryMode: BinaryMode,
  ): this

  Choose how binary data should be transported to the GUI. By default, all fields are transported as 'datauri', with the exception of primary and foreign keys.

  Using 'datauri' allows to use the FilePicker widget, while 'hex' is more suitable for short binary data (for instance binary uuids).

  Parameters

  • name: Extract<keyof S[N]["plain"], string>

    the name of the field

  • binaryMode: BinaryMode

    either 'datauri' or 'hex'

  Returns this

  Example

  .replaceFieldBinaryMode('avatar', 'datauri');
  Copy

replaceFieldOperator

• replaceFieldOperator<C extends string>(
      name: C,
      operator:
          | "Equal"
          | "NotEqual"
          | "LessThan"
          | "GreaterThan"
          | "LessThanOrEqual"
          | "GreaterThanOrEqual"
          | "Match"
          | "NotContains"
          | "NotIContains"
          | "LongerThan"
          | "ShorterThan"
          | "IncludesAll"
          | "IncludesNone"
          | "Today"
          | "Yesterday"
          | "PreviousMonth"
          | "PreviousQuarter"
          | "PreviousWeek"
          | "PreviousYear"
          | "PreviousMonthToDate"
          | "PreviousQuarterToDate"
          | "PreviousWeekToDate"
          | "PreviousXDaysToDate"
          | "PreviousXDays"
          | "PreviousYearToDate"
          | "Present"
          | "Blank"
          | "Missing"
          | "In"
          | "NotIn"
          | "StartsWith"
          | "EndsWith"
          | "Contains"
          | "IStartsWith"
          | "IEndsWith"
          | "IContains"
          | "Like"
          | "ILike"
          | "Before"
          | "After"
          | "AfterXHoursAgo"
          | "BeforeXHoursAgo"
          | "Future"
          | "Past",
      replacer: OperatorDefinition<S, N, C>,
  ): this

  Replace an implementation for a specific operator on a specific field. The operator replacement will be done by the datasource.

  Type Parameters

  • C extends string

  Parameters

  • name: C

    the name of the field to filter on

  • operator:
        | "Equal"
        | "NotEqual"
        | "LessThan"
        | "GreaterThan"
        | "LessThanOrEqual"
        | "GreaterThanOrEqual"
        | "Match"
        | "NotContains"
        | "NotIContains"
        | "LongerThan"
        | "ShorterThan"
        | "IncludesAll"
        | "IncludesNone"
        | "Today"
        | "Yesterday"
        | "PreviousMonth"
        | "PreviousQuarter"
        | "PreviousWeek"
        | "PreviousYear"
        | "PreviousMonthToDate"
        | "PreviousQuarterToDate"
        | "PreviousWeekToDate"
        | "PreviousXDaysToDate"
        | "PreviousXDays"
        | "PreviousYearToDate"
        | "Present"
        | "Blank"
        | "Missing"
        | "In"
        | "NotIn"
        | "StartsWith"
        | "EndsWith"
        | "Contains"
        | "IStartsWith"
        | "IEndsWith"
        | "IContains"
        | "Like"
        | "ILike"
        | "Before"
        | "After"
        | "AfterXHoursAgo"
        | "BeforeXHoursAgo"
        | "Future"
        | "Past"

    the operator to replace

  • replacer: OperatorDefinition<S, N, C>

    the proposed implementation

  Returns this

  See

  Documentation Link

  Example

  .replaceFieldOperator('fullName', 'Contains', (value) => {
     return {
       aggregator: 'Or',
       conditions: [{
         field: 'firstName',
         operator: 'Contains',
         value
       }, {
         field: 'lastName',
         operator: 'Contains',
         value
       }]
     }
  });
  Copy

replaceFieldSorting

• replaceFieldSorting(
      name: Extract<keyof S[N]["plain"], string>,
      equivalentSort: TSortClause<S, N>[],
  ): this

  Replace an implementation for the sorting. The field sorting will be done by the datasource.

  Parameters

  • name: Extract<keyof S[N]["plain"], string>

    the name of the field to enable sort

  • equivalentSort: TSortClause<S, N>[]

    the sort equivalent

  Returns this

  See

  @Documentation Link

  Example

  .replaceFieldSorting(
    'fullName',
    [
      { field: 'firstName', ascending: true },
      { field: 'lastName',  ascending: true },
    ]
  )
  Copy

replaceFieldWriting

• replaceFieldWriting<C extends string>(
      name: C,
      definition: WriteDefinition<S, N, C>,
  ): this

  Replace the write behavior of a field.

  Type Parameters

  • C extends string

  Parameters

  • name: C

    the name of the field

  • definition: WriteDefinition<S, N, C>

    the function or a value to represent the write behavior

  Returns this

  See

  Documentation Link

  Example

  .replaceFieldWriting('fullName', fullName => {
    const [firstName, lastName] = fullName.split(' ');
    return { firstName, lastName };
  });
  Copy

replaceSearch

• replaceSearch(definition: SearchDefinition<S, N>): this

  Replace the behavior of the search bar

  Parameters

  • definition: SearchDefinition<S, N>

    handler to describe the new behavior

  Returns this

  See

  Documentation Link

  Example

  .replaceSearch(async (searchString) => {
    return { field: 'name', operator: 'Contains', value: searchString };
  });
  Copy

setFieldNullable

• setFieldNullable(name: Extract<keyof S[N]["plain"], string>): this

  Mark a field as optional

  Be wary that your database might still refuse empty values if it requires one

  Parameters

  • name: Extract<keyof S[N]["plain"], string>

    the name of the column you would like optional

  Returns this

  Example

  .setFieldNullable('userName');
  Copy

use

• use<Options>(plugin: Plugin<Options>, options?: Options): this

  Load a plugin on the collection.

  Type Parameters

  • Options

  Parameters

  • plugin: Plugin<Options>

    reference to the plugin function

  • Optionaloptions: Options

    options to pass to the plugin

  Returns this

  See

  Documentation Link

  Example

  import { createFileField } from '@forestadmin/plugin-s3';
  
  collection.use(createFileField, { fieldname: 'avatar' }),
  Copy