@svadmin/core 0.49.1 → 0.52.0

package/src/table-state.svelte.ts

@@ -1,29 +1,29 @@
+import { definedOptions } from './defined-options';
 // TableState — Svelte 5 Class State Pattern for table data management
 // Reactive class that encapsulates all table state with fine-grained $state/$derived
 
-import { useParsed } from './useParsed.svelte';
 import { useList } from './query-hooks.svelte';
-import { readURLState, writeURLState } from './url-sync';
+import { readURLState,writeURLState } from './url-sync';
 import { captureAdminContext } from './context.svelte';
 import type { AdminContextAccessor } from './context.svelte';
-import type { Pagination, Sort, Filter, BaseRecord, HttpError, KnownResources, GetListResult } from './types';
+import type { Pagination,Sort,Filter,BaseRecord,HttpError,KnownResources } from './types';
 import type { UseListOptions } from './query-hooks.svelte';
 
-export type FilterSetMode = 'merge' | 'replace';
+export type FilterSetMode='merge'|'replace';
 
-export interface TableStateOptions<TData extends BaseRecord = BaseRecord, TError = HttpError>
-  extends Omit<UseListOptions<TData, TError>, 'pagination' | 'sorters' | 'filters'> {
+export interface TableStateOptions<TData extends BaseRecord=BaseRecord,TError=HttpError>
+  extends Omit<UseListOptions<TData,TError>,'pagination'|'sorters'|'filters'> {
   resource?: KnownResources;
   pagination?: Pagination;
   sorters?: {
     initial?: Sort[];
     permanent?: Sort[];
-    mode?: 'off' | 'server';
+    mode?: 'off'|'server';
   };
   filters?: {
     initial?: Filter[];
     permanent?: Filter[];
-    mode?: 'off' | 'server';
+    mode?: 'off'|'server';
     defaultBehavior?: FilterSetMode;
   };
   syncWithLocation?: boolean;
@@ -40,108 +40,108 @@ export interface TableStateOptions<TData extends BaseRecord = BaseRecord, TError
  * console.log(table.data); // reactive
  * ```
  */
-export class TableState<TData extends BaseRecord = BaseRecord, TError = HttpError> {
+export class TableState {
   // ─── Reactive state ───────────────────────────────────────────
-  pagination = $state<Pagination>({ current: 1, pageSize: 10 });
-  currentSorters = $state<Sort[]>([]);
-  currentFilters = $state<Filter[]>([]);
+  pagination=$state<Pagination>({ current: 1,pageSize: 10 });
+  currentSorters=$state<Sort[]>([]);
+  currentFilters=$state<Filter[]>([]);
 
   // ─── Private config ───────────────────────────────────────────
   private permanentSorters: Sort[];
   private permanentFilters: Filter[];
-  private sortersMode: 'off' | 'server';
-  private filtersMode: 'off' | 'server';
+  private sortersMode: 'off'|'server';
+  private filtersMode: 'off'|'server';
   private filterDefaultBehavior: FilterSetMode;
   private syncWithLocation: boolean;
-  private paginationMode: string;
+  private paginationMode: NonNullable<Pagination['mode']>;
   private adminContext: AdminContextAccessor;
 
   // ─── Query result ─────────────────────────────────────────────
   private _queryResult;
 
-  constructor(options: TableStateOptions<TData, TError> = {}) {
-    this.adminContext = captureAdminContext();
-    const parsed = useParsed();
-    const resource = options.resource ?? parsed.resource ?? '';
+  constructor(options: TableStateOptions={}) {
+    this.adminContext=captureAdminContext();
 
-    this.permanentSorters = options.sorters?.permanent ?? [];
-    this.permanentFilters = options.filters?.permanent ?? [];
-    this.sortersMode = options.sorters?.mode ?? 'server';
-    this.filtersMode = options.filters?.mode ?? 'server';
-    this.filterDefaultBehavior = options.filters?.defaultBehavior ?? 'replace';
-    this.syncWithLocation = options.syncWithLocation ?? false;
-    this.paginationMode = options.pagination?.mode ?? 'server';
+    this.permanentSorters=options.sorters?.permanent??[];
+    this.permanentFilters=options.filters?.permanent??[];
+    this.sortersMode=options.sorters?.mode??'server';
+    this.filtersMode=options.filters?.mode??'server';
+    this.filterDefaultBehavior=options.filters?.defaultBehavior??'replace';
+    this.syncWithLocation=options.syncWithLocation??false;
+    this.paginationMode=options.pagination?.mode??'server';
 
     // Init from URL or defaults
-    let initPagination = options.pagination ?? { current: 1, pageSize: 10 };
-    let initSorters = options.sorters?.initial ?? [];
-    let initFilters = options.filters?.initial ?? [];
-
-    if (this.syncWithLocation && typeof window !== 'undefined') {
-      const urlState = readURLState(this.adminContext);
-      if (urlState.page || urlState.pageSize) {
-        initPagination = {
-          current: urlState.page ?? initPagination.current,
-          pageSize: urlState.pageSize ?? initPagination.pageSize,
-        };
+    let initPagination=options.pagination??{ current: 1,pageSize: 10 };
+    let initSorters=options.sorters?.initial??[];
+    let initFilters=options.filters?.initial??[];
+
+    if(this.syncWithLocation&&typeof window!=='undefined') {
+      const urlState=readURLState(this.adminContext);
+      if(urlState.page||urlState.pageSize) {
+        initPagination=definedOptions({
+          current: urlState.page??initPagination.current,
+          pageSize: urlState.pageSize??initPagination.pageSize,
+        });
       }
-      if (urlState.sortField) {
-        initSorters = [{ field: urlState.sortField, order: (urlState.sortOrder as 'asc' | 'desc') ?? 'asc' }];
+      if(urlState.sortField) {
+        initSorters=[{ field: urlState.sortField,order: urlState.sortOrder??'asc' }];
       }
-      if (urlState.filters) {
-        initFilters = urlState.filters;
+      if(urlState.filters) {
+        initFilters=urlState.filters;
       }
     }
 
-    this.pagination = initPagination;
-    this.currentSorters = initSorters;
-    this.currentFilters = initFilters;
+    this.pagination=initPagination;
+    this.currentSorters=initSorters;
+    this.currentFilters=initFilters;
 
     // Create query
-    const _this = this; // eslint-disable-line @typescript-eslint/no-this-alias
-    const { meta, syncWithLocation: _s, dataProviderName, pagination: _p, sorters: _sr, filters: _f, ...restOptions } = options;
-    this._queryResult = useList<TData, TError>({
-      resource,
-      get pagination() { return _this.queryPagination; },
-      get sorters() { return _this.effectiveSorters; },
-      get filters() { return _this.effectiveFilters; },
-      meta,
-      dataProviderName,
+    const { meta,syncWithLocation: _s,dataProviderName,pagination: _p,sorters: _sr,filters: _f,...restOptions }=options;
+    this._queryResult=useList(() => ({
+      pagination: this.queryPagination,
+      sorters: this.effectiveSorters,
+      filters: this.effectiveFilters,
+      ...definedOptions({
+        meta,
+        dataProviderName,
+      }),
       ...restOptions,
-    });
+    }));
 
     // URL sync effect
-    if (this.syncWithLocation && typeof window !== 'undefined') {
+    if(this.syncWithLocation&&typeof window!=='undefined') {
       $effect(() => {
         writeURLState({
           page: this.pagination.current,
           pageSize: this.pagination.pageSize,
           sortField: this.currentSorters[0]?.field,
           sortOrder: this.currentSorters[0]?.order,
-          filters: this.currentFilters,
-        }, this.adminContext);
+          ...definedOptions({
+            filters: this.currentFilters
+          })
+        },this.adminContext);
       });
     }
   }
 
   // ─── Derived state ────────────────────────────────────────────
-  get effectiveSorters() { return [...this.currentSorters, ...this.permanentSorters]; }
-  get effectiveFilters() { return [...this.currentFilters, ...this.permanentFilters]; }
+  get effectiveSorters() { return [...this.currentSorters,...this.permanentSorters]; }
+  get effectiveFilters() { return [...this.currentFilters,...this.permanentFilters]; }
 
   private get queryPagination() {
-    return this.paginationMode === 'server'
+    return this.paginationMode==='server'
       ? this.pagination
-      : { current: 1, pageSize: 999999, mode: this.paginationMode as 'client' | 'off' };
+      :{ current: 1,pageSize: 999999,mode: this.paginationMode };
   }
 
   /** Underlying TanStack Query result */
   get query() { return this._queryResult; }
 
   /** Table data rows */
-  get data(): TData[] { return (this.query.data as GetListResult<TData> | undefined)?.data ?? []; }
+  get data(): BaseRecord[] { return this.query.data?.data??[]; }
 
   /** Total record count */
-  get total(): number { return (this.query.data as GetListResult<TData> | undefined)?.total ?? 0; }
+  get total(): number { return this.query.data?.total??0; }
 
   /** Is data loading */
   get isLoading(): boolean { return this.query.isLoading; }
@@ -150,105 +150,105 @@ export class TableState<TData extends BaseRecord = BaseRecord, TError = HttpErro
   get isError(): boolean { return this.query.isError; }
 
   /** Error object */
-  get error(): TError | null { return this.query.error; }
+  get error(): unknown { return this.query.error; }
 
   /** Current page number */
-  get current(): number { return this.pagination.current ?? 1; }
+  get current(): number { return this.pagination.current??1; }
 
   /** Page size */
-  get pageSize(): number { return this.pagination.pageSize ?? 10; }
+  get pageSize(): number { return this.pagination.pageSize??10; }
 
   /** Total number of pages */
-  get pageCount(): number { return Math.ceil(this.total / this.pageSize); }
+  get pageCount(): number { return Math.ceil(this.total/this.pageSize); }
 
   /** Has next page */
-  get hasNextPage(): boolean { return this.current < this.pageCount; }
+  get hasNextPage(): boolean { return this.current<this.pageCount; }
 
   /** Has previous page */
-  get hasPreviousPage(): boolean { return this.current > 1; }
+  get hasPreviousPage(): boolean { return this.current>1; }
 
   // ─── Mutators ─────────────────────────────────────────────────
   setPage(page: number) {
-    this.pagination = { ...this.pagination, current: page };
+    this.pagination={ ...this.pagination,current: page };
   }
 
   setPageSize(size: number) {
-    this.pagination = { ...this.pagination, pageSize: size, current: 1 };
+    this.pagination={ ...this.pagination,pageSize: size,current: 1 };
   }
 
   nextPage() {
-    if (this.hasNextPage) this.setPage(this.current + 1);
+    if(this.hasNextPage) this.setPage(this.current+1);
   }
 
   previousPage() {
-    if (this.hasPreviousPage) this.setPage(this.current - 1);
+    if(this.hasPreviousPage) this.setPage(this.current-1);
   }
 
   setSorters(newSorters: Sort[]) {
-    this.currentSorters = newSorters;
-    this.pagination = { ...this.pagination, current: 1 };
+    this.currentSorters=newSorters;
+    this.pagination={ ...this.pagination,current: 1 };
   }
 
   toggleSort(field: string) {
-    const existing = this.currentSorters.find(s => s.field === field);
-    if (!existing) {
-      this.currentSorters = [{ field, order: 'asc' }];
-    } else if (existing.order === 'asc') {
-      this.currentSorters = [{ field, order: 'desc' }];
+    const existing=this.currentSorters.find(s => s.field===field);
+    if(!existing) {
+      this.currentSorters=[{ field,order: 'asc' }];
+    } else if(existing.order==='asc') {
+      this.currentSorters=[{ field,order: 'desc' }];
     } else {
-      this.currentSorters = [];
+      this.currentSorters=[];
     }
-    this.pagination = { ...this.pagination, current: 1 };
+    this.pagination={ ...this.pagination,current: 1 };
   }
 
-  setFilters(newFilters: Filter[], mode?: FilterSetMode) {
-    const behavior = mode ?? this.filterDefaultBehavior;
-    if (behavior === 'merge') {
-      const merged = [...this.currentFilters];
-      for (const nf of newFilters) {
-        if (!('field' in nf)) { merged.push(nf); continue; }
-          const idx = merged.findIndex(f => 'field' in f && f.field === nf.field && f.operator === nf.operator);
-        if (idx >= 0) {
-          if (nf.value === undefined || nf.value === null || nf.value === '') merged.splice(idx, 1);
-          else merged[idx] = nf;
-        } else if (nf.value !== undefined && nf.value !== null && nf.value !== '') {
+  setFilters(newFilters: Filter[],mode?: FilterSetMode) {
+    const behavior=mode??this.filterDefaultBehavior;
+    if(behavior==='merge') {
+      const merged=[...this.currentFilters];
+      for(const nf of newFilters) {
+        if(!('field' in nf)) { merged.push(nf); continue; }
+        const idx=merged.findIndex(f => 'field' in f&&f.field===nf.field&&f.operator===nf.operator);
+        if(idx>=0) {
+          if(nf.value===undefined||nf.value===null||nf.value==='') merged.splice(idx,1);
+          else merged[idx]=nf;
+        } else if(nf.value!==undefined&&nf.value!==null&&nf.value!=='') {
           merged.push(nf);
         }
       }
-      this.currentFilters = merged;
+      this.currentFilters=merged;
     } else {
-      this.currentFilters = newFilters;
+      this.currentFilters=newFilters;
     }
-    this.pagination = { ...this.pagination, current: 1 };
+    this.pagination={ ...this.pagination,current: 1 };
   }
 
   resetFilters() {
-    this.currentFilters = [];
-    this.pagination = { ...this.pagination, current: 1 };
+    this.currentFilters=[];
+    this.pagination={ ...this.pagination,current: 1 };
   }
 
-  get clientData(): TData[] {
-    if (this.paginationMode === 'server') return [];
-    const allData = this.data;
-    const sorted = [...allData];
-    const activeSorters = this.sortersMode === 'off' ? this.effectiveSorters : [];
-    if (activeSorters.length > 0) {
-      sorted.sort((a, b) => {
-        for (const { field, order } of activeSorters) {
-          const va = (a as Record<string, unknown>)[field];
-          const vb = (b as Record<string, unknown>)[field];
-          if (va == null && vb == null) continue;
-          if (va == null) return 1;
-          if (vb == null) return -1;
-          const cmp = va < vb ? -1 : va > vb ? 1 : 0;
-          if (cmp !== 0) return order === 'desc' ? -cmp : cmp;
+  get clientData(): BaseRecord[] {
+    if(this.paginationMode==='server') return [];
+    const allData=this.data;
+    const sorted=[...allData];
+    const activeSorters=this.sortersMode==='off'? this.effectiveSorters:[];
+    if(activeSorters.length>0) {
+      sorted.sort((a,b) => {
+        for(const { field,order } of activeSorters) {
+          const va=a[field];
+          const vb=b[field];
+          if(va==null&&vb==null) continue;
+          if(va==null) return 1;
+          if(vb==null) return -1;
+          const cmp=va<vb? -1:va>vb? 1:0;
+          if(cmp!==0) return order==='desc'? -cmp:cmp;
         }
         return 0;
       });
     }
-    if (this.paginationMode === 'off') return sorted;
-    const start = (this.current - 1) * this.pageSize;
-    const end = start + this.pageSize;
-    return sorted.slice(start, end);
+    if(this.paginationMode==='off') return sorted;
+    const start=(this.current-1)*this.pageSize;
+    const end=start+this.pageSize;
+    return sorted.slice(start,end);
   }
 }

package/src/task-contract.ts

@@ -0,0 +1,87 @@
+import { Type, type Static } from '@sinclair/typebox';
+import { checkExact } from './schema-validation';
+import { snapshotPlainData } from './plain-data';
+
+const text = Type.String({ minLength: 1 });
+const dateValue = Type.Union([text, Type.Null()]);
+const messageValue = Type.Union([Type.String(), Type.Null()]);
+const record = Type.Record(Type.String(), Type.Unknown());
+const taskSchema = Type.Intersect([
+  Type.Object({
+    id: text,
+    name: Type.Optional(text), title: Type.Optional(text), status: Type.Optional(text),
+    progress: Type.Optional(Type.Union([Type.Number({ minimum: 0, maximum: 100 }), Type.Null()])),
+    priority: Type.Optional(Type.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER })),
+    queueName: Type.Optional(text), queue_name: Type.Optional(text),
+    message: Type.Optional(messageValue),
+    payload: Type.Optional(Type.Unknown()), result: Type.Optional(Type.Unknown()), result_data: Type.Optional(Type.Unknown()),
+    createdAt: Type.Optional(dateValue), created_at: Type.Optional(dateValue),
+    updatedAt: Type.Optional(dateValue), updated_at: Type.Optional(dateValue),
+    startedAt: Type.Optional(dateValue), started_at: Type.Optional(dateValue),
+    finishedAt: Type.Optional(dateValue), finished_at: Type.Optional(dateValue),
+    cancelledAt: Type.Optional(dateValue), cancelled_at: Type.Optional(dateValue),
+    error: Type.Optional(Type.Unknown()),
+    errorMessage: Type.Optional(messageValue), error_message: Type.Optional(messageValue),
+  }),
+  record,
+]);
+const submitSchema = Type.Object({
+  body: Type.Optional(record),
+  idempotencyKey: Type.Optional(text),
+  headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+  meta: Type.Optional(record),
+}, { additionalProperties: false });
+const listSchema = Type.Object({
+  data: Type.Array(taskSchema),
+  total: Type.Optional(Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER })),
+}, { additionalProperties: false });
+
+export type TaskRecord = Static<typeof taskSchema>;
+export type TaskDateValue = Static<typeof dateValue>;
+export type TaskMessageValue = Static<typeof messageValue>;
+export type SubmitTaskOptions = Static<typeof submitSchema>;
+
+const messages = {
+  INVALID_TASK_INPUT: 'Invalid task input.',
+  INVALID_TASK_RESPONSE: 'Invalid task response.',
+  TASK_PROVIDER_FAILED: 'Task request failed.',
+  TASK_SUBSCRIPTION_FAILED: 'Task subscription failed.',
+  TASK_CALLBACK_FAILED: 'Task callback failed.',
+} as const;
+
+export class TaskError extends Error {
+  constructor(readonly code: keyof typeof messages, readonly writeMayHaveSucceeded = false) {
+    super(messages[code]);
+    this.name = 'TaskError';
+  }
+}
+
+export function decodeTaskRecord(value: unknown, expectedId?: string, write = false): TaskRecord {
+  try {
+    const candidate = snapshotPlainData(value);
+    if (checkExact(taskSchema, candidate) && (expectedId === undefined || candidate.id === expectedId)) return candidate;
+  } catch {
+    // Do not expose submitted records or reflection errors.
+  }
+  throw new TaskError('INVALID_TASK_RESPONSE', write);
+}
+
+export function decodeTaskList(value: unknown): Static<typeof listSchema> {
+  try {
+    const candidate = snapshotPlainData(value);
+    if (checkExact(listSchema, candidate)) return candidate;
+  } catch {
+    // Normalize reflection and serialization failures.
+  }
+  throw new TaskError('INVALID_TASK_RESPONSE');
+}
+
+export function decodeTaskSubmitOptions(value: unknown): SubmitTaskOptions {
+  try {
+    const candidate = snapshotPlainData(value);
+    if (checkExact(submitSchema, candidate)) return candidate;
+  } catch {
+    // Optional fields must be omitted, not serialized as undefined.
+  }
+  throw new TaskError('INVALID_TASK_INPUT');
+}