Implementation guide

  import { goto } from '$app/navigation';
  import { pageStore } from '$lib/arch/global/PageStore';
  import IssueForm from '$lib/domain/issue/IssueForm.svelte';
  import { t } from '$lib/translations';

  const issue = $state({ (1)
    subject: ''
    // ...
  });

  async function handleAfterSave(id?: number) { (2)
    await goto(`/issues/${id}`);
  }

<IssueForm bind:issue {handleAfterSave} /> (1)

  import FormValidator from '$lib/arch/form/FormValidator';
  import InputField from '$lib/arch/form/InputField.svelte';
  import { issueStatuses } from '$lib/domain/issue/IssueStatusMasterStore';
  import { t } from '$lib/translations';
  import * as yup from 'yup';

  (1)
  interface Props {
    issue: IssueModel;
    handleAfterSave: (id?: number) => Promise<void>;
    actionBtnLabel: string;
  }

  (2)
  let { issue = $bindable(), handleAfterSave, actionBtnLabel }: Props = $props();

  (3)
  const spec = {
    subject: yup.string().required().label($t('msg.label.issue.subject'))
    // ...
  };

  const form = FormValidator.createForm(spec, save); (4)

  (5)
  async function save() {
    console.log('saved')
  }

<form use:form>  (1)
  <div>
    <InputField id="subject" label="Subject" bind:value={issue.subject} />  (2)
  </div>

  ...

    <div>
      <SelectBox
        id="status"
        label={$t('msg.status')}
        options={$issueStatuses}   (3)
        bind:value={issue.issueStatus.id}
      />
    </div>

  ...

  <div>
    <button id="save" type="submit">{actionBtnLabel}</button> (4)
  </div>
</form>

packages:
  ${project.groupId}.domain.issue:  (1)
    - issue

package dev.aulait.svqk.domain.issue;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import java.util.HashSet;
import java.util.Set;
import javax.annotation.processing.Generated;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;

@Generated("dev.aulait.jeg:jpa-entity-generator")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(onlyExplicitlyIncluded = true, callSuper = false)
@Entity
@Table(name = "issue")
public class IssueEntity extends dev.aulait.svqk.arch.jpa.BaseEntity
    implements java.io.Serializable {

  @EqualsAndHashCode.Include
  @Id
  @Column(name = "id")
  @jakarta.persistence.GeneratedValue(strategy = jakarta.persistence.GenerationType.IDENTITY)
  private Integer id;

  @Column(name = "subject")
  private String subject;

  @Column(name = "due_date")
  private java.time.LocalDate dueDate;

  @Column(name = "description")
  private String description;

  @Builder.Default
  @OneToMany(fetch = FetchType.LAZY)
  @JoinColumn(name = "issue_id", referencedColumnName = "id", insertable = false, updatable = false)
  private Set<JournalEntity> journals = new HashSet<>();

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "tracker_id", referencedColumnName = "id")
  private TrackerEntity tracker;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "status_id", referencedColumnName = "id")
  private IssueStatusEntity issueStatus;
}

package dev.aulait.svqk.domain.issue;

import static dev.aulait.svqk.arch.jpa.JpaUtils.findWithFetch;

import jakarta.persistence.EntityManager;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

public interface IssueRepository extends JpaRepository<IssueEntity, Integer> {
}

package dev.aulait.svqk.domain.issue;

@ApplicationScoped
@RequiredArgsConstructor
public class IssueService {

  private final IssueRepository repository;

  @Transactional
  public IssueEntity save(IssueEntity entity) { (1)
    return repository.save(entity); (2)
  }
}

package dev.aulait.svqk.interfaces.issue;

import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.SortedSet;
import lombok.Data;
import org.eclipse.microprofile.openapi.annotations.media.Schema;

@Data
public class IssueDto {

  @Schema(required = true, readOnly = true)
  @JsonProperty(access = JsonProperty.Access.READ_ONLY)
  private Integer id;

  @Schema(required = true)
  @NotBlank
  private String subject;

  private String description;

  private LocalDate dueDate;

  @Schema(required = true)
  private IssueStatusDto issueStatus;

  @Schema(required = true)
  private TrackerDto tracker;

  @Schema(required = true)
  private Long version;

  @Schema(required = true, readOnly = true)
  private LocalDateTime updatedAt;

  @Schema(required = true, readOnly = true)
  private SortedSet<JournalDto> journals;
}

package dev.aulait.svqk.interfaces.issue;

@Path(IssueController.ISSUES_PATH)
@RequiredArgsConstructor
public class IssueController {

  private final IssueService service;

  @POST
  public int create(@Valid IssueDto dto) { (1)

    (2)
    IssueEntity entity = BeanUtils.map(dto, IssueEntity.class);
    IssueEntity savedEntity = service.save(entity);

    return savedEntity.getId();
  }
}

  ...
  import type { IssueModel, IssueStatusModel } from '$lib/arch/api/Api';
  import ApiHandler from '$lib/arch/api/ApiHandler';
  import { messageStore } from '$lib/arch/global/MessageStore';

  interface Props {
    issue: IssueModel; (1)
    handleAfterSave: (id?: number) => Promise<void>;
    actionBtnLabel: string;
  }

  ...

  async function save() {
    (2)
    const response = await ApiHandler.handle<IdModel>(fetch, (api) =>
      api.issues.issuesCreate(issue)
    );

    (3)
    if (response) {
      await handleAfterSave(response.id);
      messageStore.show($t('msg.saved'));
    }
  }

  import type { IssueModel, IssueStatusModel } from '$lib/arch/api/Api';

  let issue = $state({
    issueStatus: {} as IssueStatusModel,
    tracker: {} as TrackerModel
  } as IssueModel); (1)

package dev.aulait.svqk.domain.issue;

import dev.aulait.sqb.SearchCriteria;
import dev.aulait.sqb.SearchResult;
import dev.aulait.sqb.jpa.JpaSearchQueryExecutor;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.persistence.EntityManager;
import jakarta.transaction.Transactional;
import java.util.List;
import lombok.RequiredArgsConstructor;

@ApplicationScoped
@RequiredArgsConstructor
public class IssueService {

  private final IssueRepository repository;
  private final EntityManager em;
  private final JpaSearchQueryExecutor searchExecutor;

  public SearchResult<IssueEntity> search(SearchCriteria criteria) { (1)
    return searchExecutor.search(em, criteria); (2)
  }
}

package dev.aulait.svqk.interfaces.issue;

import dev.aulait.sqb.PageControl;
import dev.aulait.sqb.SortOrder;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import org.eclipse.microprofile.openapi.annotations.media.Schema;

@Data (1)
public class IssueSearchCriteriaDto {
  (2)
  private String text;
  private List<String> issueStatuses = new ArrayList<>();
  private LocalDate dueDate;
  private boolean subjectOnly;

  @Schema(required = true)
  private PageControl pageControl = new PageControl();

  private List<SortOrder> sortOrders = new ArrayList<>();
}

package dev.aulait.svqk.interfaces.issue;

import static dev.aulait.sqb.ComparisonOperator.*;
import static dev.aulait.sqb.LogicalOperator.*;

import dev.aulait.sqb.LikePattern;
import dev.aulait.sqb.SearchCriteria;
import dev.aulait.sqb.SearchCriteriaBuilder;
import dev.aulait.sqb.SearchResult;
import dev.aulait.svqk.arch.util.BeanUtils;
import dev.aulait.svqk.arch.util.BeanUtils.MappingConfig;
import dev.aulait.svqk.domain.issue.IssueEntity;
import dev.aulait.svqk.domain.issue.IssueTrackingRs;
import dev.aulait.svqk.interfaces.issue.IssueController.IssueSearchResultDto;
import jakarta.enterprise.context.ApplicationScoped;
import java.util.List;

@ApplicationScoped
public class IssueFactory {

  private MappingConfig<IssueEntity, IssueDto> searchResultConfig =
      BeanUtils.buildConfig(IssueEntity.class, IssueDto.class)
          .skip(IssueDto::setJournals)
          .build(); (1)

  public SearchCriteria build(IssueSearchCriteriaDto criteria) { (2)
    Object text = LikePattern.contains(criteria.getText());

    return new SearchCriteriaBuilder() (3)
        .select("SELECT i FROM IssueEntity i")
        .select("JOIN FETCH i.issueStatus")
        .select("JOIN FETCH i.tracker")
        .where("i.subject", LIKE, text)
        .where("i.issueStatus.id", IN, criteria.getIssueStatuses())
        .where("i.dueDate", criteria.getDueDate())
        .where(OR, "i.description", LIKE, criteria.isSubjectOnly() ? null : text)
        .defaultOrderBy("i.id", false)
        .orderBy(criteria.getSortOrders())
        .build(criteria.getPageControl()); (4)
  }

  public IssueSearchResultDto build(SearchResult<IssueEntity> vo) { (5)
    return BeanUtils.map(searchResultConfig, vo, IssueSearchResultDto.class); (6)
  }
}

package dev.aulait.svqk.interfaces.issue;

import dev.aulait.sqb.SearchCriteria;
import dev.aulait.sqb.SearchResult;
import dev.aulait.svqk.arch.util.BeanUtils;
import dev.aulait.svqk.domain.issue.IssueEntity;
import dev.aulait.svqk.domain.issue.IssueService;
import dev.aulait.svqk.domain.issue.JournalEntity;
import jakarta.validation.Valid;
import jakarta.ws.rs.DELETE;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.PUT;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;
import lombok.RequiredArgsConstructor;

@Path(IssueController.ISSUES_PATH)
@RequiredArgsConstructor
public class IssueController {

  private final IssueService service;

  private final IssueFactory factory;

  static final String ISSUES_PATH = "issues";

  static final String ISSUES_SEARCH_PATH = "search";

  public static class IssueSearchResultDto extends SearchResult<IssueDto> {} (1)

  @POST
  @Path(ISSUES_SEARCH_PATH)
  public IssueSearchResultDto search(IssueSearchCriteriaDto dto) { (2)
    (3)
    SearchCriteria vo = factory.build(dto);
    SearchResult<IssueEntity> result = service.search(vo);

    return factory.build(result);
  }
}

import type { IssueSearchCriteriaModel, IssueSearchResultModel } from '$lib/arch/api/Api';
import ApiHandler from '$lib/arch/api/ApiHandler';
import CriteriaUtils from '$lib/arch/search/CriteriaUtils';
import { t } from '$lib/translations';
import type { PageLoad } from './$types';

export const load: PageLoad = async ({ fetch, url }) => {
  (1)
  const criteria = {
    issueStatuses: [],
  } as IssueSearchCriteriaModel;

  const open = false; (2)

  const result =
    (await ApiHandler.handle<IssueSearchResultModel>(fetch, (api) =>
      api.issues.issuesSearch(criteria)
    )) || ({} as IssueSearchResultModel); (3)

  return {
    title: t.get('msg.issue'),
    criteria,
    open,
    result
  };
};

  import { goto } from '$app/navigation';
  import type { IssueModel } from '$lib/arch/api/Api';
  import CheckBox from '$lib/arch/form/CheckBox.svelte';
  import FormValidator from '$lib/arch/form/FormValidator';
  import InputField from '$lib/arch/form/InputField.svelte';
  import SelectBox from '$lib/arch/form/SelectBox.svelte';
  import CriteriaUtils from '$lib/arch/search/CriteriaUtils';
  import ListTable, { ColumnsBuilder } from '$lib/arch/search/ListTable.svelte';
  import DateUtils from '$lib/arch/util/DateUtils';
  import { issueStatuses } from '$lib/domain/issue/IssueStatusMasterStore';
  import { t } from '$lib/translations';
  import type { PageData } from '../issues/$types';

  let { data }: { data: PageData } = $props();
  let { criteria, open } = $state(data);
  let { result } = $derived(data);

  const form = FormValidator.createForm({}, search); (1)

  const columns = new ColumnsBuilder<IssueModel>()
    .add('#', 'i.id', () => issueIdAnchor)
    .add($t('msg.tracker'), 'i.tracker', (issue) => issue.tracker.name)
    .add($t('msg.status'), 'i.issueStatus', (issue) => issue.issueStatus.name)
    .add($t('msg.subject'), 'i.subject', (issue) => issue.subject, ['align-left'])
    .add($t('msg.dueDate'), 'i.dueDate', (issue) => DateUtils.date(issue.dueDate))
    .add($t('msg.updatedAt'), 'i.updatedAt', (issue) => DateUtils.datetime(issue.updatedAt))
    .build(); (2)

  (3)
  function search() {

  }

<section>
  <form use:form>  (1)
    <fieldset role="search">  (2)
      <input type="search" bind:value={condition.text} />
      <input type="submit" value="Search" />
    </fieldset>

    :
  </form>
</section>

<section>
  <ListTable {result} {columns} bind:condition {search} />  (3)
</section>

<!-- for ListTable issueId Column -->
{#snippet issueIdAnchor(issue: IssueModel)}
  <a href={`/issues/${issue.id}`}>{issue.id}</a>
{/snippet}

import type { IssueSearchCriteriaModel, IssueSearchResultModel } from '$lib/arch/api/Api';
import ApiHandler from '$lib/arch/api/ApiHandler';
import CriteriaUtils from '$lib/arch/search/CriteriaUtils';
import { t } from '$lib/translations';
import type { PageLoad } from './$types';

export const load: PageLoad = async ({ fetch, url }) => {
  const criteria = {
    issueStatuses: [],
    ...CriteriaUtils.decode(url) (1)
  } as IssueSearchCriteriaModel;

  const open = CriteriaUtils.decodeParam<boolean>(url, 'open') ?? false; (2)

  :
}

(1)
  function search() {
    goto(CriteriaUtils.encode(criteria, { open }));
  }