@katlux/providers 0.1.0-beta.0 → 0.1.0-beta.2

package/services/DataProvider/CAPIFlatClientDataProvider.ts

@@ -1,199 +0,0 @@
-import { ref, type Ref } from 'vue'
-import type { IDataResult, IDataProviderOptions, ECacheStrategy } from '../types'
-import { CFlatClientDataProvider } from './CFlatClientDataProvider';
-import type { AAPIDataProvider } from './AAPIDataProvider';
-import { RequestProvider } from '../RequestProvider/RequestProvider';
-
-
-export class CAPIFlatClientDataProvider extends CFlatClientDataProvider implements AAPIDataProvider {
-
-	apiUrl: Ref<string> = ref("")
-	contextKey: Ref<string> = ref("")
-	initialLoad: Ref<boolean> = ref(true)
-	requestProvider: RequestProvider = new RequestProvider()
-	cacheStrategy: Ref<ECacheStrategy | null> = ref(null)
-	cacheLifetime: Ref<number> = ref(0)
-	refreshOnMutation: Ref<boolean | undefined> = ref(undefined)
-
-	constructor(options?: IDataProviderOptions) {
-		super(options)
-		if (options?.cacheStrategy) this.cacheStrategy.value = options.cacheStrategy
-		if (options?.cacheLifetime) this.cacheLifetime.value = options.cacheLifetime
-		if (options?.refreshOnMutation !== undefined) this.refreshOnMutation.value = options.refreshOnMutation
-	}
-	setContextKey(key: string) {
-		this.contextKey.value = key
-		this.requestProvider.cacheKey = key
-		if (this.cacheStrategy.value) this.requestProvider.setCacheProvider(this.cacheStrategy.value)
-		if (this.cacheLifetime.value) this.requestProvider.setCacheLifetime(this.cacheLifetime.value)
-	}
-	override async refreshData(options?: { disableCache?: boolean }): Promise<void> {
-		if (!this.SSR.value && import.meta.server) return;
-
-		const fetcher = async (): Promise<IDataResult> => {
-			// Register request - execution happens automatically
-			const promise = this.requestProvider.registerRequest<IDataResult>(this.apiUrl.value, {
-				deduplicate: this.deduplicate.value as boolean,
-				nuxtApp: this.nuxtApp,
-				disableCache: options?.disableCache
-			})
-
-			// If SSR is enabled and we're on server, await to ensure content is ready for rendering
-			if (this.SSR.value && import.meta.server) {
-				return await promise
-			}
-
-			// For non-SSR, return promise - useAsyncData will handle it
-			return promise
-		}
-		const key = `${this.contextKey.value}`
-
-		if (this.contextKey.value && this.initialLoad.value) {
-			const { data } = useNuxtData(key)
-			if (data.value) {
-				const result = data.value as IDataResult
-				this.setData(result.rows)
-				this.initialLoad.value = false
-				this.loading.value = false
-				return
-			}
-		}
-		if (import.meta.server && this.contextKey.value) {
-			const { data } = await useAsyncData(key, fetcher)
-			if (data.value) {
-				const result = data.value as IDataResult
-				this.setData(result.rows)
-				this.initialLoad.value = false
-				this.loading.value = false
-				return
-			}
-		}
-
-		// For non-SSR client-side, register and handle asynchronously
-		if (!this.SSR.value) {
-			const promise = this.requestProvider.registerRequest<IDataResult>(this.apiUrl.value, {
-				deduplicate: this.deduplicate.value as boolean,
-				nuxtApp: this.nuxtApp,
-				disableCache: options?.disableCache
-			})
-			// Don't await - deliver when finished
-			promise.then((returnedData) => {
-				this.initialLoad.value = false
-				this.loading.value = false
-				this.setData(returnedData.rows)
-			}).catch(() => {
-				this.initialLoad.value = false
-				this.loading.value = false
-			})
-			return
-		}
-
-		// SSR client-side or fallback: await the request
-		const returnedData: IDataResult = await fetcher()
-		this.initialLoad.value = false
-		this.loading.value = false
-		this.setData(returnedData.rows)
-	}
-	async setAPIUrl(url: string) {
-		this.loading.value = true
-		this.apiUrl.value = url
-		this.setContextKey(url)
-		if (this.allData.value.length == 0)
-			await this.refreshData()
-	}
-
-	async create(item: any): Promise<void> {
-		if (!this.apiUrl.value) return
-
-		const result = await this.requestProvider.registerRequest(this.apiUrl.value, {
-			method: 'POST',
-			body: item,
-			nuxtApp: this.nuxtApp
-		})
-
-		if (this.refreshOnMutation.value) {
-			await this.refreshData({ disableCache: true })
-		} else {
-			if (result && (result as any).item) {
-				this.allData.value.push((result as any).item)
-				this.loadPageData() // Refresh view
-			} else {
-				await this.refreshData({ disableCache: true })
-			}
-
-			if (this.requestProvider.cacheProvider) {
-				await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value)
-			}
-			if (this.contextKey.value) {
-				clearNuxtData(this.contextKey.value)
-			}
-		}
-	}
-
-	async update(item: any): Promise<void> {
-		if (!this.apiUrl.value) return
-
-		const result = await this.requestProvider.registerRequest(this.apiUrl.value, {
-			method: 'PUT',
-			body: item,
-			nuxtApp: this.nuxtApp
-		})
-
-		if (this.refreshOnMutation.value) {
-			await this.refreshData({ disableCache: true })
-		} else {
-			// Local update
-			// We don't have idKey property on CFlatClientDataProvider explicitly defined like Tree, 
-			// assuming 'id' or we need to look at implementation.
-			// CFlatClientDataProvider doesn't enforce idKey. Assuming 'id' for now as standard.
-			const index = this.allData.value.findIndex(row => row['id'] === item['id'])
-			if (index !== -1) {
-				if (result && (result as any).item) {
-					this.allData.value[index] = (result as any).item
-				} else {
-					this.allData.value[index] = { ...this.allData.value[index], ...item }
-				}
-				this.loadPageData()
-			}
-
-			if (this.requestProvider.cacheProvider) {
-				await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value)
-			}
-			if (this.contextKey.value) {
-				clearNuxtData(this.contextKey.value)
-			}
-		}
-	}
-
-	async delete(items: any[]): Promise<void> {
-		if (!this.apiUrl.value) return
-		if (!items || items.length === 0) return
-
-		const ids = items.map(i => i.id)
-
-		// Use RequestProvider for the delete request
-		await this.requestProvider.registerRequest(this.apiUrl.value, {
-			method: 'DELETE',
-			body: { id: ids },
-			nuxtApp: this.nuxtApp
-		})
-
-		if (this.refreshOnMutation.value) {
-			// Refresh data from server with cache disabled
-			await this.refreshData({ disableCache: true })
-		} else {
-			// Optimization: Remove deleted items locally instead of refetching
-			const idsToDelete = new Set(ids)
-			this.allData.value = this.allData.value.filter(row => !idsToDelete.has(row["id"]))
-
-			// Clear the cache for this provider to prevent stale data on reload
-			if (this.requestProvider.cacheProvider) {
-				await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value)
-			}
-			// Also clear Nuxt's internal cache for this key
-			if (this.contextKey.value) {
-				clearNuxtData(this.contextKey.value)
-			}
-		}
-	}
-}

package/services/DataProvider/CAPIFlatServerDataProvider.ts

@@ -1,77 +0,0 @@
-import { ref, type Ref } from 'vue'
-import type { IDataResult, IDataFilter, IDataSort, IDataProviderOptions, ECacheStrategy } from '../types'
-import { CFlatServerDataProvider } from './CFlatServerDataProvider';
-import type { AAPIDataProvider } from './AAPIDataProvider';
-import { RequestProvider } from '../RequestProvider/RequestProvider';
-
-
-export class CAPIFlatServerDataProvider extends CFlatServerDataProvider implements AAPIDataProvider {
-
-	apiUrl: Ref<string> = ref("")
-	requestProvider: RequestProvider = new RequestProvider()
-	cacheStrategy: Ref<ECacheStrategy | null> = ref(null)
-	cacheLifetime: Ref<number> = ref(0)
-	refreshOnMutation: Ref<boolean | undefined> = ref(true) // Default true for server
-
-	constructor(options?: IDataProviderOptions) {
-		super(options)
-		if (options?.cacheStrategy) this.cacheStrategy.value = options.cacheStrategy
-		if (options?.cacheLifetime) this.cacheLifetime.value = options.cacheLifetime
-		if (options?.refreshOnMutation !== undefined) this.refreshOnMutation.value = options.refreshOnMutation
-
-	}
-	async setAPIUrl(url: string) {
-		this.apiUrl.value = url
-		this.setContextKey(url)
-		if (this.cacheStrategy.value) this.requestProvider.setCacheProvider(this.cacheStrategy.value)
-		if (this.cacheLifetime.value) this.requestProvider.setCacheLifetime(this.cacheLifetime.value)
-
-		await this.setPageDataHandler(
-			async (
-				currentPage: number,
-				pageSize: number,
-				filter: IDataFilter,
-				sortList: IDataSort[],
-				options?: { disableCache?: boolean }
-			): Promise<IDataResult> => {
-				// Register request - execution happens automatically
-				// Always await the promise - loadPageData will decide whether to await the fetcher
-				return await this.requestProvider.registerRequest<IDataResult>(this.apiUrl.value, {
-					query: {
-						pageNumber: currentPage,
-						pageSize: pageSize,
-						filter: filter,
-						sortList: sortList,
-					},
-					deduplicate: this.deduplicate.value as boolean,
-					nuxtApp: this.nuxtApp,
-					disableCache: options?.disableCache
-				})
-			}
-		)
-	}
-
-	async delete(items: any[]): Promise<void> {
-		if (!this.apiUrl.value) return
-		if (!items || items.length === 0) return
-
-		const ids = items.map(i => i.id)
-
-		// Use RequestProvider for the delete request
-		await this.requestProvider.registerRequest(this.apiUrl.value, {
-			method: 'DELETE',
-			body: { id: ids },
-			nuxtApp: this.nuxtApp
-		})
-
-		// Refresh data (refetch from server)
-		if (this.refreshOnMutation.value !== false) {
-			// Clear client-side cache for this resource
-			if (this.requestProvider.cacheProvider) {
-				await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value)
-			}
-
-			this.loadPageData({ disableCache: true })
-		}
-	}
-}

package/services/DataProvider/CAPITreeClientDataProvider.ts

@@ -1,205 +0,0 @@
-import { ref, type Ref } from 'vue'
-import type { IDataResult, ITreeDataProviderOptions, ECacheStrategy } from '../types'
-import { CTreeClientDataProvider } from './CTreeClientDataProvider'
-import type { AAPIDataProvider } from './AAPIDataProvider'
-import { RequestProvider } from '../RequestProvider/RequestProvider'
-
-
-export class CAPITreeClientDataProvider extends CTreeClientDataProvider implements AAPIDataProvider {
-
-	apiUrl: Ref<string> = ref("")
-	contextKey: Ref<string> = ref("")
-	initialLoad: Ref<boolean> = ref(true)
-	requestProvider: RequestProvider = new RequestProvider()
-	cacheStrategy: Ref<ECacheStrategy | null> = ref(null)
-	cacheLifetime: Ref<number> = ref(0)
-	refreshOnMutation: Ref<boolean | undefined> = ref(undefined)
-
-	constructor(options?: ITreeDataProviderOptions) {
-		super(options)
-		if (options?.cacheStrategy) this.cacheStrategy.value = options.cacheStrategy
-		if (options?.cacheLifetime) this.cacheLifetime.value = options.cacheLifetime
-		if (options?.refreshOnMutation !== undefined) this.refreshOnMutation.value = options.refreshOnMutation
-	}
-
-	setContextKey(key: string) {
-		this.contextKey.value = key
-		this.requestProvider.cacheKey = key
-		if (this.cacheStrategy.value) this.requestProvider.setCacheProvider(this.cacheStrategy.value)
-		if (this.cacheLifetime.value) this.requestProvider.setCacheLifetime(this.cacheLifetime.value)
-	}
-
-	override async refreshData(options?: { disableCache?: boolean }): Promise<void> {
-		if (!this.SSR.value && import.meta.server) return;
-
-		const fetcher = async (): Promise<IDataResult> => {
-			// Register request - execution happens automatically
-			const promise = this.requestProvider.registerRequest<IDataResult>(this.apiUrl.value, {
-				deduplicate: this.deduplicate.value as boolean,
-				nuxtApp: this.nuxtApp,
-				disableCache: options?.disableCache
-			})
-
-			// If SSR is enabled and we're on server, await to ensure content is ready for rendering
-			if (this.SSR.value && import.meta.server) {
-				return await promise
-			}
-
-			// For non-SSR, return promise - useAsyncData will handle it
-			return promise
-		}
-		const key = `${this.contextKey.value}`
-
-		if (this.contextKey.value && this.initialLoad.value) {
-			const { data } = useNuxtData(key)
-			if (data.value) {
-				const result = data.value as IDataResult
-				this.setData(result.rows)
-				this.initialLoad.value = false
-				this.loading.value = false
-				return
-			}
-		}
-		if (import.meta.server && this.contextKey.value) {
-			const { data } = await useAsyncData(key, fetcher)
-			if (data.value) {
-				const result = data.value as IDataResult
-				this.setData(result.rows)
-				this.initialLoad.value = false
-				this.loading.value = false
-				return
-			}
-		}
-
-		// For non-SSR client-side, register and handle asynchronously
-		if (!this.SSR.value) {
-			const promise = this.requestProvider.registerRequest<IDataResult>(this.apiUrl.value, {
-				deduplicate: this.deduplicate.value as boolean,
-				nuxtApp: this.nuxtApp,
-				disableCache: options?.disableCache
-			})
-			// Don't await - deliver when finished
-			promise.then((returnedData) => {
-				this.initialLoad.value = false
-				this.loading.value = false
-				this.setData(returnedData.rows)
-			}).catch(() => {
-				this.initialLoad.value = false
-				this.loading.value = false
-			})
-			return
-		}
-
-		// SSR client-side or fallback: await the request
-		const returnedData: IDataResult = await fetcher()
-		this.initialLoad.value = false
-		this.loading.value = false
-		this.setData(returnedData.rows)
-	}
-
-	async setAPIUrl(url: string) {
-		this.loading.value = true
-		this.apiUrl.value = url
-		this.setContextKey(url)
-		if (this.allData.value.length == 0)
-			await this.refreshData()
-	}
-
-	async create(item: any): Promise<void> {
-		if (!this.apiUrl.value) return
-
-		// Use RequestProvider for the create request
-		const result = await this.requestProvider.registerRequest(this.apiUrl.value, {
-			method: 'POST',
-			body: item,
-			nuxtApp: this.nuxtApp
-		})
-
-		if (this.refreshOnMutation.value) {
-			await this.refreshData({ disableCache: true })
-		} else {
-			// Optimistic UI update or fetch fresh data
-			if (result && (result as any).item) {
-				this.allData.value.push((result as any).item)
-			} else {
-				// Fallback if no item returned
-				await this.refreshData({ disableCache: true })
-			}
-
-			// Clear cache
-			if (this.requestProvider.cacheProvider) {
-				await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value)
-			}
-			if (this.contextKey.value) {
-				clearNuxtData(this.contextKey.value)
-			}
-		}
-	}
-
-	async update(item: any): Promise<void> {
-		if (!this.apiUrl.value) return
-
-		// Use RequestProvider for the update request
-		const result = await this.requestProvider.registerRequest(this.apiUrl.value, {
-			method: 'PUT',
-			body: item,
-			nuxtApp: this.nuxtApp
-		})
-
-		if (this.refreshOnMutation.value) {
-			await this.refreshData({ disableCache: true })
-		} else {
-			// Local update
-			const index = this.allData.value.findIndex(row => row[this.idKey] === item[this.idKey])
-			if (index !== -1) {
-				if (result && (result as any).item) {
-					this.allData.value[index] = (result as any).item
-				} else {
-					this.allData.value[index] = { ...this.allData.value[index], ...item }
-				}
-				// Trigger reactivity
-				this.allData.value = [...this.allData.value]
-			}
-
-			// Clear cache
-			if (this.requestProvider.cacheProvider) {
-				await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value)
-			}
-			if (this.contextKey.value) {
-				clearNuxtData(this.contextKey.value)
-			}
-		}
-	}
-
-	async delete(items: any[]): Promise<void> {
-		if (!this.apiUrl.value) return
-		if (!items || items.length === 0) return
-
-		const ids = items.map(i => i.id)
-
-		// Use RequestProvider for the delete request
-		await this.requestProvider.registerRequest(this.apiUrl.value, {
-			method: 'DELETE',
-			body: { id: ids },
-			nuxtApp: this.nuxtApp
-		})
-
-		if (this.refreshOnMutation.value) {
-			// Refresh data from server with cache disabled
-			await this.refreshData({ disableCache: true })
-		} else {
-			// Optimization: Remove deleted items locally instead of refetching
-			const idsToDelete = new Set(ids)
-			this.allData.value = this.allData.value.filter(row => !idsToDelete.has(row[this.idKey])) // Use this.idKey
-
-			// Clear the cache for this provider to prevent stale data on reload
-			if (this.requestProvider.cacheProvider) {
-				await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value)
-			}
-			// Also clear Nuxt's internal cache for this key
-			if (this.contextKey.value) {
-				clearNuxtData(this.contextKey.value)
-			}
-		}
-	}
-}

package/services/DataProvider/CAPITreeServerDataProvider.ts

@@ -1,98 +0,0 @@
-import { ref, type Ref } from 'vue'
-import type { IDataResult, IDataFilter, IDataSort, ITreeDataProviderOptions, ECacheStrategy, TreePaginationMode } from '../types'
-import { CTreeServerDataProvider } from './CTreeServerDataProvider';
-import type { AAPIDataProvider } from './AAPIDataProvider';
-import { RequestProvider } from '../RequestProvider/RequestProvider';
-
-
-/**
- * API-based Server-side Tree Data Provider
- * 
- * Extends CTreeServerDataProvider with:
- * - API URL configuration
- * - Request management (caching, deduplication)
- * - Automatic tree parameter serialization in query
- */
-export class CAPITreeServerDataProvider extends CTreeServerDataProvider implements AAPIDataProvider {
-
-	apiUrl: Ref<string> = ref("")
-	requestProvider: RequestProvider = new RequestProvider()
-	cacheStrategy: Ref<ECacheStrategy | null> = ref(null)
-	cacheLifetime: Ref<number> = ref(0)
-	refreshOnMutation: Ref<boolean | undefined> = ref(true) // Default true for server
-
-	constructor(options?: ITreeDataProviderOptions) {
-		super(options)
-		if (options?.cacheStrategy) this.cacheStrategy.value = options.cacheStrategy
-		if (options?.cacheLifetime) this.cacheLifetime.value = options.cacheLifetime
-		if (options?.refreshOnMutation !== undefined) this.refreshOnMutation.value = options.refreshOnMutation
-	}
-
-	async setAPIUrl(url: string) {
-		this.apiUrl.value = url
-		this.setContextKey(url)
-		if (this.cacheStrategy.value) this.requestProvider.setCacheProvider(this.cacheStrategy.value)
-		if (this.cacheLifetime.value) this.requestProvider.setCacheLifetime(this.cacheLifetime.value)
-
-		await this.setPageDataHandler(
-			async (
-				currentPage: number,
-				pageSize: number,
-				filter: IDataFilter,
-				sortList: IDataSort[],
-				treeParams: {
-					expandedNodes: (string | number)[],
-					parentKey: string,
-					idKey: string,
-					paginateBy: TreePaginationMode,
-					expandedByDefault: boolean
-				},
-				options?: { disableCache?: boolean }
-			): Promise<IDataResult> => {
-				// Send all parameters to server for server-side tree pagination
-				return await this.requestProvider.registerRequest<IDataResult>(this.apiUrl.value, {
-					query: {
-						pageNumber: currentPage,
-						pageSize: pageSize,
-						filter: filter,
-						sortList: sortList,
-						// Tree-specific params for server-side processing
-						expandedNodes: JSON.stringify(treeParams.expandedNodes),
-						parentKey: treeParams.parentKey,
-						idKey: treeParams.idKey,
-						paginateBy: treeParams.paginateBy,
-						expandedByDefault: treeParams.expandedByDefault
-					},
-					deduplicate: this.deduplicate.value as boolean,
-					nuxtApp: this.nuxtApp,
-					disableCache: options?.disableCache
-				})
-			}
-		)
-	}
-
-	async delete(items: any[]): Promise<void> {
-		if (!this.apiUrl.value) return
-		if (!items || items.length === 0) return
-
-		const ids = items.map(i => i.id)
-
-		// Use RequestProvider for the delete request
-		await this.requestProvider.registerRequest(this.apiUrl.value, {
-			method: 'DELETE',
-			body: { id: ids },
-			nuxtApp: this.nuxtApp
-		})
-
-		if (this.refreshOnMutation.value !== false) {
-			// Clear client-side cache for this resource to ensure consistency (e.g. other pages/filters)
-			if (this.requestProvider.cacheProvider) {
-				await this.requestProvider.cacheProvider.removeByPrefix(this.apiUrl.value)
-			}
-
-			// Trigger reload which calls the setPageDataHandler defined above
-			// Disable cache to ensure fresh data
-			this.loadPageData({ disableCache: true })
-		}
-	}
-}

package/services/DataProvider/CFlatClientDataProvider.ts

@@ -1,52 +0,0 @@
-import { ref, type Ref } from 'vue'
-import { ADataProvider } from './ADataProvider'
-import type { TDataRow, IDataFilter, IDataProviderOptions } from '../types'
-import { useFilterLogic } from '@katlux/toolkit/composables/useFilterLogic'
-import { useSortLogic } from '@katlux/toolkit/composables/useSortLogic'
-
-const { evaluateFilter, filterData } = useFilterLogic()
-const { sortData } = useSortLogic()
-
-
-export class CFlatClientDataProvider extends ADataProvider {
-	allData: Ref<TDataRow[]> = ref([])
-	filteredData: Ref<TDataRow[]> = ref([])
-
-	constructor(options?: IDataProviderOptions) {
-		super(options)
-	}
-
-	setData(data: TDataRow[]) {
-		this.allData.value = [...data]
-		this.loadPageData()
-	}
-
-	async loadPageData(): Promise<void> {
-
-		// Apply filters
-		if (!this.filter.value) {
-			this.filteredData.value = this.allData.value
-		} else {
-			const { results } = filterData(this.allData.value, this.filter.value)
-			this.filteredData.value = results
-		}
-		this.rowCount.value = this.filteredData.value.length
-
-		// Apply sort
-		if (this.sortList.value.length > 0)
-			this.filteredData.value = sortData(this.sortList.value, this.filteredData.value)
-		// Apply pagination (pageSize <= 0 means no pagination)
-		if (this.pageSize.value <= 0) {
-			this.pageData.value = this.filteredData.value
-		} else {
-			const startIndex = (this.currentPage.value - 1) * this.pageSize.value
-			const endIndex = startIndex + this.pageSize.value
-			this.pageData.value = this.filteredData.value.slice(startIndex, endIndex)
-		}
-	}
-
-	refreshData(): void {
-
-	}
-
-}