@aurorajs.dev/catalyst-cli 1.0.0

package/dist/templates/frontend/application/src/@aurora/components/search-select/search-select.component.ts

@@ -0,0 +1,86 @@
+import { ChangeDetectionStrategy, Component, computed, input, output } from '@angular/core';
+import { HlmComboboxImports } from '@spartan-ng/helm/combobox';
+import type { Option } from '../types';
+
+/**
+ * Synchronous, searchable single-select for many-to-one relationships with a
+ * medium catalog (20–500 options) preloaded by the route resolver. Filter is
+ * client-side via Spartan's default combobox filter — no debounce, no fetch.
+ *
+ * For multi-select, see `<au-multiple-search-select>`.
+ * For server-side search (>500 options), see `<au-async-search-select>`.
+ *
+ * @example
+ * <au-search-select
+ *   [inputId]="'clientId'"
+ *   [value]="form.controls.clientId.value"
+ *   [options]="clientOptions()"
+ *   [emptyMessage]="t('Aurora.NoResults')"
+ *   (valueChange)="form.controls.clientId.setValue($event)"
+ *   (touched)="form.controls.clientId.markAsTouched()"
+ * />
+ */
+@Component({
+  selector: 'au-search-select',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  imports: [HlmComboboxImports],
+  host: { class: 'block' },
+  template: `
+    <hlm-combobox
+      class="w-full"
+      [value]="selectedOption()"
+      [disabled]="disabled()"
+      [itemToString]="optionToString"
+      [isItemEqualToValue]="optionEqual"
+      (valueChange)="onValueChange($event)"
+      (closed)="touched.emit()"
+    >
+      <hlm-combobox-input
+        [inputId]="inputId()"
+        [placeholder]="placeholder()"
+      />
+      <hlm-combobox-content *hlmComboboxPortal>
+        <hlm-combobox-empty>{{ emptyMessage() }}</hlm-combobox-empty>
+        <div hlmComboboxList>
+          @for (opt of options(); track opt.value) {
+            <hlm-combobox-item
+              [value]="opt"
+              [disabled]="opt.disabled ?? false"
+            >
+              {{ opt.label }}
+            </hlm-combobox-item>
+          }
+        </div>
+      </hlm-combobox-content>
+    </hlm-combobox>
+
+    @if (errorMessage(); as err) {
+      <p class="text-destructive mt-1 text-xs">{{ err }}</p>
+    }
+  `,
+})
+export class SearchSelect {
+  readonly value = input<string | null>(null);
+  readonly options = input<Option[]>([]);
+  readonly inputId = input<string>('');
+  readonly placeholder = input<string>('Search...');
+  readonly disabled = input<boolean>(false);
+  readonly emptyMessage = input<string>('No results');
+  readonly errorMessage = input<string | null>(null);
+
+  readonly valueChange = output<string | null>();
+  readonly touched = output<void>();
+
+  protected readonly selectedOption = computed<Option | null>(() => {
+    const current = this.value();
+    if (current === null) return null;
+    return this.options().find((o) => o.value === current) ?? null;
+  });
+
+  protected readonly optionToString = (opt: Option | null) => opt?.label ?? '';
+  protected readonly optionEqual = (a: Option | null, b: Option | null) => a?.value === b?.value;
+
+  protected onValueChange(option: Option | null): void {
+    this.valueChange.emit(option?.value ?? null);
+  }
+}

package/dist/templates/frontend/application/src/@aurora/components/search-select/search-select.stories.ts

@@ -0,0 +1,130 @@
+import type { Meta, StoryObj } from '../../story.types';
+import type { Option } from '../types';
+import { SearchSelect } from './search-select.component';
+
+type Story = StoryObj<SearchSelect>;
+
+const fewOptions: Option[] = [
+  { value: 'c1', label: 'Acme Corporation' },
+  { value: 'c2', label: 'Globex Industries' },
+  { value: 'c3', label: 'Initech Technologies' },
+  { value: 'c4', label: 'Umbrella Labs' },
+];
+
+const mediumOptions: Option[] = Array.from({ length: 80 }, (_, i) => ({
+  value: `u${i + 1}`,
+  label: `User ${String(i + 1).padStart(3, '0')}`,
+}));
+
+const meta: Meta<SearchSelect> = {
+  title: '@aurora/components/search-select',
+  component: SearchSelect,
+  tags: ['autodocs'],
+  argTypes: {
+    value: {
+      control: 'text',
+      description: 'Currently selected option value (id). `null` means no selection.',
+    },
+    options: {
+      control: 'object',
+      description:
+        'Full preloaded option list. Filtering happens client-side via Spartan combobox default filter.',
+    },
+    placeholder: { control: 'text' },
+    disabled: { control: 'boolean' },
+    emptyMessage: {
+      control: 'text',
+      description:
+        'Shown inside the popover when the user query filters out every option. Should be already translated by the host (e.g. `t("Aurora.NoResults")`).',
+    },
+    errorMessage: {
+      control: 'text',
+      description:
+        'Optional error message rendered below the combobox. Host passes the already-translated string.',
+    },
+    valueChange: { action: 'valueChange' },
+  },
+  args: {
+    value: null,
+    options: fewOptions,
+    placeholder: 'Select client...',
+    disabled: false,
+    emptyMessage: 'No results',
+    errorMessage: null,
+  },
+  parameters: {
+    aurora: {
+      category: 'form',
+      when: 'Many-to-one relationship picker for medium-sized catalogs (20–500 options). Runtime target of the YAML `widget.type: search-select`. All options preloaded by the resolver — no server roundtrip on each keystroke.',
+      whenNot:
+        'For <20 options use `<hlm-select>` (no need for filter UX). For >500 use `<au-async-search-select>` (server-side search). For multi-select use `<au-multiple-search-select>`.',
+    },
+  },
+};
+
+export default meta;
+
+export const Default: Story = {};
+
+export const WithPreselected: Story = {
+  name: 'With preselected value',
+  args: {
+    value: 'c2',
+    options: fewOptions,
+  },
+  parameters: {
+    docs: {
+      description: {
+        story:
+          'Component initializes with a value already set (typical edit mode). The trigger shows the label of the pre-selected option via `itemToString`.',
+      },
+    },
+  },
+};
+
+export const MediumList: Story = {
+  name: 'Medium option list (80 items)',
+  args: {
+    options: mediumOptions,
+    placeholder: 'Search user...',
+  },
+  parameters: {
+    docs: {
+      description: {
+        story:
+          'Eighty options to validate that client-side filter behaves correctly while the user types. The popover scrolls and keyboard navigation (Arrow Up/Down, Home/End) works inside `hlm-combobox-list`.',
+      },
+    },
+  },
+};
+
+export const Empty: Story = {
+  args: {
+    options: [],
+    emptyMessage: 'No results matched your search',
+  },
+  parameters: {
+    docs: {
+      description: {
+        story:
+          'Empty list scenario — also fired when the user types a query that filters out all options.',
+      },
+    },
+  },
+};
+
+export const Disabled: Story = {
+  args: {
+    disabled: true,
+    placeholder: 'Disabled',
+    options: fewOptions,
+  },
+};
+
+export const Error: Story = {
+  name: 'With error message',
+  args: {
+    value: null,
+    errorMessage: 'Select a client to continue',
+  },
+};

package/dist/templates/frontend/application/src/@aurora/components/types.ts

@@ -0,0 +1,10 @@
+/**
+ * Canonical option shape for selector-style components (async-select-search and
+ * future select-like primitives). Entities rendered in grid components use
+ * `DataTableColumnDef<T>` from `./data-table/types` instead.
+ */
+export interface Option<T = string> {
+  value: T;
+  label: string;
+  disabled?: boolean;
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/auth/index.ts

@@ -0,0 +1,2 @@
+export * from './use-password-generator';
+export * from './use-password-toggle';

package/dist/templates/frontend/application/src/@aurora/composables/atoms/auth/use-password-generator.ts

@@ -0,0 +1,11 @@
+import { createPassword, type CreatePasswordOptions } from '../../../lib/create-password';
+
+export interface UsePasswordGeneratorResult {
+  generate(overrides?: Partial<CreatePasswordOptions>): string;
+}
+
+export const usePasswordGenerator = (
+  defaults: CreatePasswordOptions,
+): UsePasswordGeneratorResult => ({
+  generate: (overrides) => createPassword({ ...defaults, ...overrides }),
+});

package/dist/templates/frontend/application/src/@aurora/composables/atoms/auth/use-password-toggle.ts

@@ -0,0 +1,18 @@
+import { computed, Signal, signal, WritableSignal } from '@angular/core';
+
+export interface UsePasswordToggleResult {
+  readonly visible: WritableSignal<boolean>;
+  readonly type: Signal<'text' | 'password'>;
+  toggle(): void;
+}
+
+export const usePasswordToggle = (initialVisible = false): UsePasswordToggleResult => {
+  const visible = signal(initialVisible);
+  const type = computed<'text' | 'password'>(() => (visible() ? 'text' : 'password'));
+
+  return {
+    visible,
+    type,
+    toggle: () => visible.update((current) => !current),
+  };
+};

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/index.ts

@@ -0,0 +1,26 @@
+export { useTableSearch } from './use-table-search';
+export type { TableSearchAtom } from './use-table-search';
+
+export { useTableSort } from './use-table-sort';
+export type { TableSortAtom } from './use-table-sort';
+
+export { useTablePagination } from './use-table-pagination';
+export type { TablePaginationAtom } from './use-table-pagination';
+
+export { useTableFilters } from './use-table-filters';
+export type { TableFiltersAtom } from './use-table-filters';
+
+export { useTableSelection } from './use-table-selection';
+export type { TableSelectionAtom } from './use-table-selection';
+
+export { useTableColumnVisibility } from './use-table-column-visibility';
+export type { TableColumnVisibilityAtom } from './use-table-column-visibility';
+
+export { useTableColumnOrder } from './use-table-column-order';
+export type { TableColumnOrderAtom } from './use-table-column-order';
+
+export { useTableExport } from './use-table-export';
+export type { TableExportAtom } from './use-table-export';
+
+export { useTableData } from './use-table-data';
+export type { TableDataAtom, TableDataConfig, TableDataFetchInput } from './use-table-data';

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/use-table-column-order.ts

@@ -0,0 +1,19 @@
+import { signal, type Signal } from '@angular/core';
+import type { ColumnOrderState } from '@tanstack/angular-table';
+
+export interface TableColumnOrderAtom {
+  readonly state: Signal<ColumnOrderState>;
+  set(s: ColumnOrderState): void;
+}
+
+/**
+ * Atom: column order. Single responsibility — owns a `ColumnOrderState`
+ * signal (an array of column ids in display order).
+ */
+export function useTableColumnOrder(initial: ColumnOrderState = []): TableColumnOrderAtom {
+  const state = signal(initial);
+  return {
+    state: state.asReadonly(),
+    set: (s: ColumnOrderState) => state.set(s),
+  };
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/use-table-column-pinning.ts

@@ -0,0 +1,25 @@
+import { signal, type Signal } from '@angular/core';
+import type { ColumnPinningState } from '@tanstack/angular-table';
+
+export interface TableColumnPinningAtom {
+  readonly state: Signal<ColumnPinningState>;
+  set(s: ColumnPinningState): void;
+}
+
+/**
+ * Atom: column pinning. Single responsibility — owns a `ColumnPinningState`
+ * signal (`{ left: string[]; right: string[] }`). Used by `useDataTable` to
+ * power TanStack Table's column pinning feature, which guarantees that
+ * pinned columns form a contiguous group on the chosen edge and exposes
+ * pre-calculated cumulative offsets via `column.getStart('left')` /
+ * `column.getAfter('right')`.
+ */
+export function useTableColumnPinning(
+  initial: ColumnPinningState = { left: [], right: [] },
+): TableColumnPinningAtom {
+  const state = signal(initial);
+  return {
+    state: state.asReadonly(),
+    set: (s: ColumnPinningState) => state.set(s),
+  };
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/use-table-column-visibility.ts

@@ -0,0 +1,20 @@
+import { signal, type Signal } from '@angular/core';
+import type { VisibilityState } from '@tanstack/angular-table';
+
+export interface TableColumnVisibilityAtom {
+  readonly state: Signal<VisibilityState>;
+  set(s: VisibilityState): void;
+}
+
+/**
+ * Atom: column visibility. Single responsibility — owns a `VisibilityState`
+ * signal. Persistence-by-gridId is delegated to a separate wrapper
+ * composable (not part of this atom) to keep the responsibility unitary.
+ */
+export function useTableColumnVisibility(initial: VisibilityState = {}): TableColumnVisibilityAtom {
+  const state = signal(initial);
+  return {
+    state: state.asReadonly(),
+    set: (s: VisibilityState) => state.set(s),
+  };
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/use-table-data.ts

@@ -0,0 +1,68 @@
+import { inject, Injector, runInInjectionContext, signal, type Signal } from '@angular/core';
+import { firstValueFrom, type Observable } from 'rxjs';
+import type { DataTableData } from '../../../components/data-table/types';
+
+export interface TableDataFetchInput {
+  readonly query: Record<string, unknown>;
+  readonly constraint?: Record<string, unknown>;
+}
+
+export interface TableDataConfig<T> {
+  /**
+   * Server-paginated fetch function. Typically `useGraphqlList(...).paginate`
+   * or `useGraphqlPaginate(...).paginate` or any equivalent that accepts a
+   * `{ query, constraint? }` input and emits `Observable<DataTableData<T>>`.
+   * Generic by design — `useTableData` does not depend on GraphQL.
+   */
+  readonly fetch: (input: TableDataFetchInput) => Observable<DataTableData<T>>;
+}
+
+export interface TableDataAtom<T> {
+  readonly data: Signal<DataTableData<T>>;
+  readonly loading: Signal<boolean>;
+  refetch(input: TableDataFetchInput): Promise<void>;
+  seed(d: DataTableData<T>): void;
+}
+
+/**
+ * Atom: server-paginated data loader. Single responsibility — owns `data`
+ * and `loading` signals plus an imperative `refetch(input)` and a `seed(d)`
+ * to preserve resolver prefetch.
+ *
+ * The atom does NOT build the query — that's the orchestrator's job (e.g.
+ * `usePaginatedDataTable` builds `{ query, constraint }` from the search,
+ * sort, pagination, filters atoms and passes it to `refetch`). This keeps
+ * `useTableData` agnostic to query-builder helpers.
+ *
+ * MUST be invoked from an injection context — uses `inject(Injector)` so
+ * that `firstValueFrom` runs in a child context that exists for the
+ * lifetime of the host component.
+ */
+export function useTableData<T>(config: TableDataConfig<T>): TableDataAtom<T> {
+  const injector = inject(Injector);
+  const data = signal<DataTableData<T>>({ count: 0, total: 0, rows: [] });
+  const loading = signal(false);
+
+  async function refetch(input: TableDataFetchInput): Promise<void> {
+    loading.set(true);
+    try {
+      const result = await runInInjectionContext(injector, () =>
+        firstValueFrom(config.fetch(input)),
+      );
+      data.set(result);
+    } finally {
+      loading.set(false);
+    }
+  }
+
+  function seed(d: DataTableData<T>): void {
+    data.set(d);
+  }
+
+  return {
+    data: data.asReadonly(),
+    loading: loading.asReadonly(),
+    refetch,
+    seed,
+  };
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/use-table-export.ts

@@ -0,0 +1,54 @@
+import type { Table } from '@tanstack/angular-table';
+import type { LabeledColumn } from '../../../components/data-table/types';
+
+export interface TableExportAtom {
+  exportCsv<T>(table: Table<T>, columns: LabeledColumn[], filename: string): void;
+  exportXls<T>(table: Table<T>, columns: LabeledColumn[], filename: string): void;
+}
+
+/**
+ * Atom: table export helpers. Single responsibility — generates CSV/XLS
+ * blobs from the visible rows of a TanStack `Table<T>` and triggers a
+ * browser download. Stateless — pure functions wrapped as an atom for
+ * uniformity with the other table atoms.
+ *
+ * Exports the CURRENT page only. Full-dataset export is a separate concern
+ * (typically requires a fetcher call, not a table operation).
+ */
+export function useTableExport(): TableExportAtom {
+  return {
+    exportCsv<T>(table: Table<T>, columns: LabeledColumn[], filename: string): void {
+      const csv = generateCsv(table, columns);
+      downloadFile(csv, `${filename}.csv`, 'text/csv');
+    },
+    exportXls<T>(table: Table<T>, columns: LabeledColumn[], filename: string): void {
+      const csv = generateCsv(table, columns);
+      downloadFile(csv, `${filename}.xls`, 'application/vnd.ms-excel');
+    },
+  };
+}
+
+function generateCsv<T>(table: Table<T>, columns: LabeledColumn[]): string {
+  const rows = table.getRowModel().rows;
+  const header = columns.map((c) => `"${c.label}"`).join(';');
+  const body = rows.map((row) =>
+    columns
+      .map((c) => {
+        const value = String(row.getValue(c.key) ?? '').replace(/"/g, '""');
+        return `"${value}"`;
+      })
+      .join(';'),
+  );
+  return [header, ...body].join('\n');
+}
+
+function downloadFile(content: string, filename: string, mimeType: string): void {
+  const bom = '';
+  const blob = new Blob([bom + content], { type: `${mimeType};charset=utf-8` });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/use-table-filters.ts

@@ -0,0 +1,22 @@
+import { signal, type Signal } from '@angular/core';
+import type { ColumnFilter } from '../../../components/data-table/types';
+
+export interface TableFiltersAtom {
+  readonly value: Signal<ColumnFilter[]>;
+  set(f: ColumnFilter[]): void;
+}
+
+/**
+ * Atom: column filters. Single responsibility — owns the catalyst-shape
+ * `ColumnFilter[]` signal used by `buildFilterWhere` to assemble Sequelize
+ * `where` clauses. NOT TanStack's `ColumnFiltersState` — that's a separate
+ * shape used internally by TanStack which the binding layer derives if
+ * needed.
+ */
+export function useTableFilters(initialValue: ColumnFilter[] = []): TableFiltersAtom {
+  const value = signal(initialValue);
+  return {
+    value: value.asReadonly(),
+    set: (f: ColumnFilter[]) => value.set(f),
+  };
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/use-table-pagination.ts

@@ -0,0 +1,30 @@
+import { computed, signal, type Signal } from '@angular/core';
+import type { PaginationState } from '@tanstack/angular-table';
+import { DEFAULT_PAGE_SIZE } from '../../../components/data-table/types';
+
+export interface TablePaginationAtom {
+  readonly state: Signal<PaginationState>;
+  readonly offset: Signal<number>;
+  readonly limit: Signal<number>;
+  set(s: PaginationState): void;
+}
+
+/**
+ * Atom: pagination state. Single responsibility — owns a `PaginationState`
+ * signal and exposes derived `offset`/`limit` accessors typically needed when
+ * building a server query.
+ */
+export function useTablePagination(
+  defaultPageSize: number = DEFAULT_PAGE_SIZE,
+): TablePaginationAtom {
+  const state = signal<PaginationState>({ pageIndex: 0, pageSize: defaultPageSize });
+  const offset = computed(() => state().pageIndex * state().pageSize);
+  const limit = computed(() => state().pageSize);
+
+  return {
+    state: state.asReadonly(),
+    offset,
+    limit,
+    set: (s: PaginationState) => state.set(s),
+  };
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/use-table-search.ts

@@ -0,0 +1,36 @@
+import { signal, type Signal } from '@angular/core';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { debounceTime, distinctUntilChanged } from 'rxjs';
+
+const DEFAULT_DEBOUNCE_MS = 300;
+
+export interface TableSearchAtom {
+  readonly value: Signal<string>;
+  readonly debouncedValue: Signal<string>;
+  set(s: string): void;
+}
+
+/**
+ * Atom: free-text search query. Single responsibility — owns the search
+ * string. Exposes a debounced projection so consumers can react to settled
+ * input without re-firing on every keystroke.
+ *
+ * MUST be invoked from an injection context (component constructor or
+ * `runInInjectionContext`) because `toSignal` requires it.
+ */
+export function useTableSearch(
+  initialValue = '',
+  debounceMs = DEFAULT_DEBOUNCE_MS,
+): TableSearchAtom {
+  const valueSignal = signal(initialValue);
+  const debouncedValue = toSignal(
+    toObservable(valueSignal).pipe(debounceTime(debounceMs), distinctUntilChanged()),
+    { initialValue },
+  );
+
+  return {
+    value: valueSignal.asReadonly(),
+    debouncedValue,
+    set: (s: string) => valueSignal.set(s),
+  };
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/use-table-selection.ts

@@ -0,0 +1,71 @@
+import { computed, signal, type Signal } from '@angular/core';
+import type { RowSelectionState } from '@tanstack/angular-table';
+
+export interface TableSelectionAtom {
+  readonly ids: Signal<Set<string>>;
+  toggleId(id: string): void;
+  setIds(newIds: string[] | Set<string>): void;
+  clear(): void;
+  isSelected(id: string): boolean;
+  /**
+   * Derives a TanStack `RowSelectionState` from the internal Set + a
+   * reactive list of currently-visible row ids. The result includes only
+   * visible ids that are also in the Set, while the internal Set preserves
+   * any id that fell out of the visible window — that's the cross-page
+   * persistence guarantee. The host typically passes the visible ids from
+   * `data().rows.map(r => r.id)`.
+   */
+  toRowSelectionState(visibleIds: Signal<string[]>): Signal<RowSelectionState>;
+}
+
+/**
+ * Atom: row selection by id. Single responsibility — owns a `Set<string>`
+ * of selected ids. The Set survives any change in the visible row window
+ * (paginate/sort/filter), making cross-page bulk operations possible.
+ *
+ * The host wires this atom to TanStack via the binding layer (`useDataTable`)
+ * by passing `getRowId: r => r.id` and using `toRowSelectionState(...)` to
+ * derive the TanStack `state.rowSelection`.
+ */
+export function useTableSelection(initialIds: string[] = []): TableSelectionAtom {
+  const ids = signal<Set<string>>(new Set(initialIds));
+
+  function toggleId(id: string): void {
+    const next = new Set(ids());
+    if (next.has(id)) next.delete(id);
+    else next.add(id);
+    ids.set(next);
+  }
+
+  function setIds(newIds: string[] | Set<string>): void {
+    ids.set(new Set(newIds));
+  }
+
+  function clear(): void {
+    ids.set(new Set());
+  }
+
+  function isSelected(id: string): boolean {
+    return ids().has(id);
+  }
+
+  function toRowSelectionState(visibleIds: Signal<string[]>): Signal<RowSelectionState> {
+    return computed(() => {
+      const set = ids();
+      const state: RowSelectionState = {};
+      for (const id of visibleIds()) {
+        if (set.has(id)) state[id] = true;
+      }
+      return state;
+    });
+  }
+
+  return {
+    ids: ids.asReadonly(),
+    toggleId,
+    setIds,
+    clear,
+    isSelected,
+    toRowSelectionState,
+  };
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/data-table/use-table-sort.ts

@@ -0,0 +1,19 @@
+import { signal, type Signal } from '@angular/core';
+import type { SortingState } from '@tanstack/angular-table';
+
+export interface TableSortAtom {
+  readonly state: Signal<SortingState>;
+  set(s: SortingState): void;
+}
+
+/**
+ * Atom: sort state. Single responsibility — owns a `SortingState` signal
+ * compatible with TanStack Table.
+ */
+export function useTableSort(initialState: SortingState = []): TableSortAtom {
+  const state = signal(initialState);
+  return {
+    state: state.asReadonly(),
+    set: (s: SortingState) => state.set(s),
+  };
+}

package/dist/templates/frontend/application/src/@aurora/composables/atoms/graphql/index.ts

@@ -0,0 +1,10 @@
+export { useGraphqlCreate } from './use-graphql-create';
+export { useGraphqlDelete } from './use-graphql-delete';
+export { useGraphqlDeleteById } from './use-graphql-delete-by-id';
+export { useGraphqlDeleteByKeys } from './use-graphql-delete-by-keys';
+export { useGraphqlFind } from './use-graphql-find';
+export { useGraphqlFindById } from './use-graphql-find-by-id';
+export { useGraphqlGet } from './use-graphql-get';
+export { useGraphqlInsert } from './use-graphql-insert';
+export { useGraphqlPaginate } from './use-graphql-paginate';
+export { useGraphqlUpdate } from './use-graphql-update';