Filtering results

import { InjectionToken, inject, provideAppInitializer } from "@angular/core";
import { type AtomicClient, createAtomicClient } from "@sinequa/atomic";

/** The client, injectable anywhere. One instance for the whole application. */
export const SINEQUA = new InjectionToken<AtomicClient>("Sinequa client", {
  factory: () =>
    createAtomicClient({
      app: "<your-app>",
      backendUrl: "https://<your-sinequa-server>",
    }),
});

/**
 * Resolves the configuration and the session before the first view renders, so no
 * component has to guard against an unauthenticated client.
 */
export function provideSinequa() {
  return provideAppInitializer(async () => {
    const client = inject(SINEQUA);
    await client.initializeConfig();
    await client.auth.login();
  });
}

import type { ApplicationConfig } from "@angular/core";
import { provideSinequa } from "./sinequa";

export const appConfig: ApplicationConfig = {
  providers: [provideSinequa()],
};

import { ChangeDetectionStrategy, Component, inject, resource, signal } from "@angular/core";
import { filter } from "@sinequa/atomic";
import { SINEQUA } from "./sinequa";

@Component({
  selector: "app-results",
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <label>
      <input type="checkbox" [checked]="pdfOnly()" (change)="pdfOnly.set(!pdfOnly())" />
      PDF only
    </label>

    @if (results.isLoading()) {
      <p>Searching…</p>
    } @else if (results.error()) {
      <p>Search failed: {{ results.error()?.message }}</p>
    } @else {
      <p>{{ results.value()?.rowCount ?? 0 }} matching document(s)</p>
      <ul>
        @for (record of results.value()?.records ?? []; track record.id) {
          <li>{{ record.title }} — {{ record.docformat }}</li>
        }
      </ul>
    }
  `,
})
export class ResultsComponent {
  private readonly client = inject(SINEQUA);

  readonly text = signal("quarterly report");
  readonly pdfOnly = signal(false);

  readonly results = resource({
    params: () => ({ text: this.text(), pdfOnly: this.pdfOnly() }),
    loader: ({ params }) =>
      this.client.api.query.search({
        name: "<your-query>",
        text: params.text,
        pageSize: 10,
        // An unchecked box is `false`, which `and` drops — no branch needed here.
        filters: filter.and(params.pdfOnly && filter.eq("docformat", "pdf")),
      }),
  });
}

import { createAtomicClient } from "@sinequa/atomic";

export const sinequa = createAtomicClient({
  app: "<your-app>",
  backendUrl: "https://<your-sinequa-server>",
});

/**
 * Started once at module load, awaited by every component that queries. Keeping it
 * a promise rather than a state flag means concurrent components share one sign-in
 * instead of racing to start their own.
 */
export const ready = (async () => {
  await sinequa.initializeConfig();
  await sinequa.auth.login();
})();

import { filter } from "@sinequa/atomic";
import type { Result } from "@sinequa/atomic";
import { useEffect, useState } from "react";
import { ready, sinequa } from "./sinequa";

export function SearchResults() {
  const [pdfOnly, setPdfOnly] = useState(false);
  const [result, setResult] = useState<Result>();
  const [error, setError] = useState<Error>();

  useEffect(() => {
    let active = true;
    setError(undefined);

    ready
      .then(() =>
        sinequa.api.query.search({
          name: "<your-query>",
          text: "quarterly report",
          pageSize: 10,
          // An unchecked box is `false`, which `and` drops — no branch needed here.
          filters: filter.and(pdfOnly && filter.eq("docformat", "pdf")),
        }),
      )
      .then((next) => {
        if (active) setResult(next);
      })
      .catch((cause: unknown) => {
        if (active) setError(cause as Error);
      });

    // The checkbox can flip before the previous search answers; ignore the stale one.
    return () => {
      active = false;
    };
  }, [pdfOnly]);

  if (error) return <p>Search failed: {error.message}</p>;
  if (!result) return <p>Searching…</p>;

  return (
    <>
      <label>
        <input type="checkbox" checked={pdfOnly} onChange={() => setPdfOnly(!pdfOnly)} />
        PDF only
      </label>

      <p>{result.rowCount} matching document(s)</p>
      <ul>
        {result.records.map((record) => (
          <li key={record.id}>
            {record.title} — {record.docformat}
          </li>
        ))}
      </ul>
    </>
  );
}