@fayz-ai/saas 0.1.6

package/src/stores/createCrudStore.ts

@@ -0,0 +1,138 @@
+import { create } from 'zustand'
+import type { DataProvider, CrudQuery } from '@fayz-ai/core'
+
+export interface CrudState<T> {
+  items: T[] | null
+  total: number
+  loading: boolean
+  query: CrudQuery
+}
+
+export interface ImportBatchResult<T> {
+  item?: T
+  error?: string
+}
+
+export interface CrudActions<T> {
+  fetch: () => Promise<void>
+  create: (data: any) => Promise<T>
+  /** Batch create without per-item list refetch. Calls onProgress after each batch. Single fetch at the end. */
+  createMany: (
+    rows: any[],
+    options?: { batchSize?: number; onProgress?: (processed: number, total: number) => void },
+  ) => Promise<{ success: number; results: ImportBatchResult<T>[] }>
+  update: (id: string, data: Partial<T>) => Promise<T>
+  remove: (id: string) => Promise<void>
+  setQuery: (query: Partial<CrudQuery>) => void
+  getById: (id: string) => T | undefined
+}
+
+export type CrudStore<T> = CrudState<T> & CrudActions<T>
+
+export function createCrudStore<T extends { id: string }>(
+  dataProvider: DataProvider<T>,
+) {
+  // Dedup: track the current in-flight fetch to avoid duplicate requests
+  let inflightFetch: Promise<void> | null = null
+  let lastQueryKey = ''
+
+  function queryKey(query: CrudQuery): string {
+    return JSON.stringify(query)
+  }
+
+  return create<CrudStore<T>>((set, get) => ({
+    items: null,
+    total: 0,
+    loading: false,
+    query: {},
+
+    async fetch() {
+      const currentKey = queryKey(get().query)
+
+      // If we already have an in-flight request for the same query, reuse it
+      if (inflightFetch && currentKey === lastQueryKey) {
+        return inflightFetch
+      }
+
+      lastQueryKey = currentKey
+      set({ loading: true })
+
+      const promise = (async () => {
+        try {
+          const result = await dataProvider.list(get().query)
+          set({ items: result.data, total: result.total, loading: false })
+        } catch {
+          set({ items: get().items ?? [], loading: false })
+        } finally {
+          inflightFetch = null
+        }
+      })()
+
+      inflightFetch = promise
+      return promise
+    },
+
+    async create(data) {
+      const item = await dataProvider.create(data)
+      inflightFetch = null // invalidate dedup cache
+      lastQueryKey = ''
+      await get().fetch()
+      return item
+    },
+
+    async createMany(rows, options) {
+      const batchSize = options?.batchSize ?? 10
+      let success = 0
+      const results: ImportBatchResult<T>[] = new Array(rows.length)
+
+      for (let i = 0; i < rows.length; i += batchSize) {
+        const batch = rows.slice(i, i + batchSize)
+        const settled = await Promise.allSettled(
+          batch.map((row) => dataProvider.create(row)),
+        )
+        for (let j = 0; j < settled.length; j++) {
+          const r = settled[j]
+          if (r.status === 'fulfilled' && r.value?.id) {
+            success++
+            results[i + j] = { item: r.value }
+          } else {
+            const msg = r.status === 'rejected' ? (r.reason?.message ?? 'Error') : 'No record returned'
+            results[i + j] = { error: msg }
+          }
+        }
+        options?.onProgress?.(Math.min(i + batch.length, rows.length), rows.length)
+      }
+
+      // Single list refresh after all inserts
+      inflightFetch = null
+      lastQueryKey = ''
+      await get().fetch()
+
+      return { success, results }
+    },
+
+    async update(id, data) {
+      const item = await dataProvider.update(id, data)
+      inflightFetch = null
+      lastQueryKey = ''
+      await get().fetch()
+      return item
+    },
+
+    async remove(id) {
+      await dataProvider.remove(id)
+      inflightFetch = null
+      lastQueryKey = ''
+      await get().fetch()
+    },
+
+    setQuery(partial) {
+      set((s) => ({ query: { ...s.query, ...partial } }))
+      queueMicrotask(() => get().fetch())
+    },
+
+    getById(id) {
+      return (get().items ?? []).find((item) => item.id === id)
+    },
+  }))
+}

package/src/supabase/client.ts

@@ -0,0 +1,54 @@
+import { createClient, type SupabaseClient } from '@supabase/supabase-js'
+import { setGlobalSupabaseClient } from '@fayz-ai/core'
+
+/** Schema name for core platform tables */
+export const CORE_SCHEMA = 'saas_core'
+
+let _client: SupabaseClient | null = null
+
+/**
+ * Create (and cache) the Supabase client for the Fayz app.
+ * Also registers it as the global client in @fayz-ai/core so data providers
+ * can resolve it without prop-drilling.
+ *
+ * Idempotent — subsequent calls with the same URL return the cached client.
+ */
+export function createFayzSupabaseClient(url: string, anonKey: string): SupabaseClient {
+  if (_client) return _client
+
+  if (!url || !anonKey) {
+    throw new Error(
+      '[@fayz-ai/saas] Supabase URL and anon key are required. ' +
+        'Pass supabaseUrl and supabaseAnonKey to createFayzApp.',
+    )
+  }
+
+  _client = createClient(url, anonKey, {
+    auth: { autoRefreshToken: true, persistSession: true },
+  })
+
+  // Register globally so @fayz-ai/core data providers can use it
+  setGlobalSupabaseClient(_client)
+
+  return _client
+}
+
+/** Get the cached client — throws if not initialised */
+export function getFayzSupabaseClient(): SupabaseClient {
+  if (!_client) {
+    throw new Error(
+      '[@fayz-ai/saas] Supabase client not initialised. Call createFayzApp with supabaseUrl and supabaseAnonKey first.',
+    )
+  }
+  return _client
+}
+
+/** Safe getter — returns null if not initialised (mock/offline mode) */
+export function getFayzSupabaseClientOptional(): SupabaseClient | null {
+  return _client
+}
+
+/** Get a client scoped to the core platform schema */
+export function getCoreSchemaClient(): ReturnType<SupabaseClient['schema']> {
+  return getFayzSupabaseClient().schema(CORE_SCHEMA)
+}