Lime Web Components API Documentation - v7.9.0
    Preparing search index...

    Interface FilterRepository

    Repository for managing saved filter definitions.

    FilterRepository provides methods to create, update, and delete Filter definitions. Filters are named, reusable query expressions that can be applied to limetypes to define subsets of objects (e.g., "My Active Deals", "High Priority Tickets").

    Filters can be:

    • System-wide (available to all users)
    • User-specific (private to a single user when iduser is set)
    • Referenced in InFilterExpressions for advanced queries

    The repository extends StateRepository, enabling:

    • Reactive subscriptions to filter changes
    • Automatic UI updates when filters are created or deleted
    • Integration with state decorators
    import {
        Filter,
        Operator,
        PlatformServiceName,
    } from '@limetech/lime-web-components';

    const repository = platform.get(PlatformServiceName.FilterRepository);

    const highValueDeals: Filter = {
        id: 'high_value_deals',
        limetype: 'deal',
        name: { en: 'High Value Deals' },
        filter: {
            op: Operator.AND,
            exp: [
                { key: 'status', op: Operator.EQUALS, exp: 'active' },
                { key: 'value', op: Operator.GREATER_OR_EQUAL, exp: 100_000 },
            ],
        },
    };

    await repository.save(highValueDeals);

    await repository.delete(highValueDeals);
    interface FilterRepository {
        delete(filter: Filter): Promise<void>;
        getFilter?(id: string): Filter | undefined;
        save(filter: Filter): Promise<void>;
        subscribe(
            callback: (...args: unknown[]) => void,
            options?: StateOptions,
        ): () => void;
    }

    Hierarchy (View Summary)

    Index

    Methods

    delete getFilter? save subscribe

    Methods

    • Delete a filter from the database.

      Permanently removes the specified filter. This operation cannot be undone.

      Parameters

      Returns Promise<void>

      Promise that resolves when the filter is deleted

      Error if deletion fails due to permissions or other issues

      import { State } from '@stencil/core';
      import {
          Filter,
          PlatformServiceName,
          SelectFilters,
      } from '@limetech/lime-web-components';

      class MyComponent {
          @State()
          @SelectFilters({ limetype: 'deal' })
          private dealFilters: Filter[];

          private async deleteFilter(id: string) {
              const filter = this.dealFilters.find(
                  (candidate) => candidate.id === id
              );

              if (!filter) {
                  return;
              }

              const repository = platform.get(PlatformServiceName.FilterRepository);
              await repository.delete(filter);
          }
      }
      • Filter for the filter structure
      • save to create or update a filter
    • Beta

      Get a loaded filter by id.

      Reads from the filters the repository already holds, so it does not make a request. Returns undefined if no filter has the id, or if the filters have not been loaded yet.

      Parameters

      • id: string

        The id of the Filter

      Returns Filter | undefined

      The Filter, or undefined if not found

      import { PlatformServiceName } from '@limetech/lime-web-components';

      const filters = platform.get(PlatformServiceName.FilterRepository);
      const language = platform.get(PlatformServiceName.Application).getLanguage();

      const filter = filters.getFilter?.('high_value_deals');

      if (filter) {
          console.log('Filter:', filter.name[language]);
      }

    • Save a filter definition to the database.

      Creates a new filter or updates an existing one. The filter will be stored persistently and become available for use in queries and filter expressions.

      If a filter with the same id already exists, it will be updated with the new values. Otherwise, a new filter is created.

      Parameters

      Returns Promise<void>

      Promise that resolves when the filter is saved

      Error if save fails due to validation or permission issues

      import {
          Filter,
          Operator,
          PlatformServiceName,
      } from '@limetech/lime-web-components';

      const filters = platform.get(PlatformServiceName.FilterRepository);
      const application = platform.get(PlatformServiceName.Application);

      const currentUser = application.getCurrentUser();

      if (currentUser) {
          const myDeals: Filter = {
              id: 'my_deals',
              limetype: 'deal',
              name: { en: 'My Deals' },
              filter: {
                  key: 'owner',
                  op: Operator.EQUALS,
                  exp: currentUser.id,
              },
              // Setting iduser keeps the filter private to this user.
              iduser: currentUser.id,
          };

          await filters.save(myDeals);
      }

    • Subscribe to state changes with optional transformation and filtering.

      The subscription will immediately invoke the callback with the current state (if any), then continue to call it whenever the state changes. The map and filter options allow you to transform and selectively receive updates.

      Parameters

      • callback: (...args: unknown[]) => void

        Function called with state updates (after map/filter applied)

      • Optionaloptions: StateOptions

        Optional transformations and filters for the subscription

      Returns () => void

      Unsubscribe function - call this to stop receiving updates

      • Map functions are applied sequentially to transform the state
      • Filter functions must all return true for the callback to be invoked
      • Functions in map/filter arrays are bound to the component instance
      • Always store and call the unsubscribe function when component is destroyed
      import { PlatformServiceName } from '@limetech/lime-web-components';

      const repository = platform.get(PlatformServiceName.Application);
      const logger = platform
          .get(PlatformServiceName.Logger)
          .createLogger('my-component');

      // Basic subscription
      const unsubscribeState = repository.subscribe((state) => {
          logger.debug('State updated', { state });
      });

      // With transformations
      const unsubscribeFullname = repository.subscribe(
          (fullname) => logger.debug('User', { fullname }),
          { map: [(state) => state.currentUser?.fullname] }
      );

    Settings

    Member Visibility

    On This Page

    Methods