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 {issue} {handleAfterSave} actionBtnLabel={$t('msg.register')} /> (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 lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Getter
@Setter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "issue")
public class IssueEntity extends dev.aulait.svqk.arch.jpa.BaseEntity
    implements java.io.Serializable {

  @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", insertable = false, updatable = false)
  private Set<JournalEntity> journals = new HashSet<>();

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

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "status_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 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)
  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.svqk.arch.jpa.SearchUtils;
import dev.aulait.svqk.arch.search.SearchCriteriaVo;
import dev.aulait.svqk.arch.search.SearchResultVo;
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;

  public SearchResultVo<IssueEntity> search(SearchCriteriaVo criteria) { (1)
    return SearchUtils.search(em, criteria); (2)
  }

package dev.aulait.svqk.interfaces.issue;

import dev.aulait.svqk.arch.search.SearchCriteriaDto;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import lombok.EqualsAndHashCode;

@Data
@EqualsAndHashCode(callSuper = true) (1)
public class IssueSearchCriteriaDto extends SearchCriteriaDto { (2)
  (3)
  private String text;
  private List<IssueStatusDto> issueStatuses = new ArrayList<>();
  private LocalDate dueDate;
  private boolean subjectOnly;
}

package dev.aulait.svqk.interfaces.issue;

import static dev.aulait.svqk.arch.search.ArithmeticOperatorCd.*;
import static dev.aulait.svqk.arch.search.LogicalOperatorCd.*;

import dev.aulait.svqk.arch.search.SearchCriteriaBuilder;
import dev.aulait.svqk.arch.search.SearchCriteriaVo;
import dev.aulait.svqk.arch.search.SearchResultVo;
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.IssueStatusEntity;
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 SearchCriteriaVo build(IssueSearchCriteriaDto criteria) { (2)
    SearchCriteriaBuilder builder =
        new SearchCriteriaBuilder()
            .select("SELECT i FROM IssueEntity i")
            .select("JOIN FETCH i.issueStatus s")
            .select("JOIN FETCH i.tracker t")
            .where("i.subject", LIKE, criteria.getText()); (3)

    if (!criteria.isSubjectOnly()) {
      builder.where(OR, "i.description", LIKE, criteria.getText());
    }

    var statuses = BeanUtils.mapAll(criteria.getIssueStatuses(), IssueStatusEntity.class);

    return builder
        .where("i.issueStatus", IN, statuses)
        .where("i.dueDate", criteria.getDueDate())
        .defaultOrderBy("i.id", false)
        .build(criteria); (4)
  }

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

package dev.aulait.svqk.interfaces.issue;

import dev.aulait.svqk.arch.search.SearchCriteriaVo;
import dev.aulait.svqk.arch.search.SearchResultDto;
import dev.aulait.svqk.arch.search.SearchResultVo;
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.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 SearchResultDto<IssueDto> {} (1)

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

    return factory.build(result);
  }

}

export interface IssueSearchCriteriaModel {
  /** @format int32 */
  pageNumber?: number;
  /** @format int32 */
  pageSize?: number;
  /** @format int32 */
  pageNumsRange?: number;
  sortOrders?: SortOrderModel[];
  text?: string;
  issueStatuses?: IssueStatusModel[];
  dueDate?: LocalDate;
  subjectOnly?: boolean;
}

export interface IssueSearchResultModel {
  list: IssueModel[];
  pageCtrl: PageControlModel;
}

export interface PageControlModel {
  /** @format int64 */
  count: number;
  /** @format int32 */
  pageSize: number;
  /** @format int32 */
  start: number;
  /** @format int32 */
  end: number;
  /** @format int32 */
  lastPage: number;
  pageNums: number[];
}

export interface SortOrderModel {
  asc?: boolean;
  field?: string;
}

export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
  issues = {
    /**
     * No description
     *
     * @tags Issue Controller
     * @name IssuesSearch
     * @request POST:/api/issues/search
     */
    issuesSearch: (data: IssueSearchCriteriaModel, params: RequestParams = {}) =>
      this.request<IssueSearchResultModel, any>({
        path: `/api/issues/search`,
        method: 'POST',
        body: data,
        type: ContentType.Json,
        format: 'json',
        ...params
      }),
  };
}

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

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

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

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

  import type { IssueModel, IssueSearchResultModel } from '$lib/arch/api/Api';
  import ApiHandler from '$lib/arch/api/ApiHandler';
  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 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 { result, condition } = $state(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)
  async 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}

  async function search() {
    (1)
    const r = await ApiHandler.handle<IssueSearchResultModel>(fetch, (api) =>
      api.issues.issuesSearch(condition)
    );

    (2)
    if (r) {
      result = r;
    }
  }