@fayz-ai/saas 0.1.6

package/src/shell/lib/schedule-service.ts

@@ -0,0 +1,307 @@
+// ---------------------------------------------------------------------------
+// Standalone Schedule CRUD Service
+// Works outside the agenda plugin context — uses Supabase directly.
+// ---------------------------------------------------------------------------
+
+import { getCoreClient } from './supabase'
+import { useOrganizationStore } from '../stores/organization.store'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ScheduleRecord {
+  id: string
+  tenantId: string
+  kind: string
+  assigneeId: string | null
+  locationId: string | null
+  dayOfWeek: number | null
+  specificDate: string | null
+  startsAt: string
+  endsAt: string
+  isActive: boolean
+  metadata: Record<string, unknown>
+}
+
+export interface SaveScheduleInput {
+  assigneeId: string
+  locationId?: string
+  dayOfWeek?: number
+  specificDate?: string
+  startsAt: string
+  endsAt: string
+  isActive?: boolean
+  kind?: string
+}
+
+/** Advanced settings stored per schedule block in the metadata jsonb column. */
+export interface BlockSettings {
+  bufferMinutes?: number
+  allowedServiceIds?: string[]
+  maxConcurrent?: number
+  minAdvanceHours?: number
+  maxAdvanceDays?: number
+  label?: string
+  locationId?: string
+}
+
+/** Extract BlockSettings from a schedule record's metadata. */
+export function parseBlockSettings(metadata: Record<string, unknown>): BlockSettings {
+  return {
+    bufferMinutes: typeof metadata.bufferMinutes === 'number' ? metadata.bufferMinutes : undefined,
+    allowedServiceIds: Array.isArray(metadata.allowedServiceIds) ? metadata.allowedServiceIds : undefined,
+    maxConcurrent: typeof metadata.maxConcurrent === 'number' ? metadata.maxConcurrent : undefined,
+    minAdvanceHours: typeof metadata.minAdvanceHours === 'number' ? metadata.minAdvanceHours : undefined,
+    maxAdvanceDays: typeof metadata.maxAdvanceDays === 'number' ? metadata.maxAdvanceDays : undefined,
+    label: typeof metadata.label === 'string' ? metadata.label : undefined,
+    locationId: typeof metadata.locationId === 'string' ? metadata.locationId : undefined,
+  }
+}
+
+/** Merge BlockSettings into existing metadata object. */
+export function mergeBlockSettings(metadata: Record<string, unknown>, settings: BlockSettings): Record<string, unknown> {
+  const merged = { ...metadata }
+  // Only set defined values, remove undefined ones to keep metadata clean
+  for (const [key, value] of Object.entries(settings)) {
+    if (value !== undefined && value !== null && !(Array.isArray(value) && value.length === 0)) {
+      merged[key] = value
+    } else {
+      delete merged[key]
+    }
+  }
+  return merged
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getTenantId(): string {
+  const id = useOrganizationStore.getState().currentOrg?.id
+  if (!id) throw new Error('No active tenant')
+  return id
+}
+
+function mapRow(row: Record<string, unknown>): ScheduleRecord {
+  const r: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(row)) {
+    r[key.replace(/_([a-z])/g, (_, c) => c.toUpperCase())] = value
+  }
+  return r as unknown as ScheduleRecord
+}
+
+// ---------------------------------------------------------------------------
+// Service functions
+// ---------------------------------------------------------------------------
+
+export async function getSchedules(
+  assigneeId: string,
+  kind = 'working_hours',
+): Promise<ScheduleRecord[]> {
+  const core = getCoreClient()
+  const { data, error } = await core
+    .from('schedules')
+    .select('*')
+    .eq('kind', kind)
+    .eq('assignee_id', assigneeId)
+    .order('day_of_week')
+    .order('starts_at')
+
+  if (error) throw error
+  return (data ?? []).map(mapRow)
+}
+
+export async function saveSchedule(input: SaveScheduleInput): Promise<ScheduleRecord> {
+  const core = getCoreClient()
+  const tenantId = getTenantId()
+
+  const { data, error } = await core
+    .from('schedules')
+    .insert({
+      tenant_id: tenantId,
+      kind: input.kind ?? 'working_hours',
+      assignee_id: input.assigneeId,
+      location_id: input.locationId ?? null,
+      day_of_week: input.dayOfWeek ?? null,
+      specific_date: input.specificDate ?? null,
+      starts_at: input.startsAt,
+      ends_at: input.endsAt,
+      is_active: input.isActive ?? true,
+    })
+    .select('*')
+    .single()
+
+  if (error) throw error
+  return mapRow(data as Record<string, unknown>)
+}
+
+export async function deleteSchedule(id: string): Promise<void> {
+  const core = getCoreClient()
+  const { error } = await core.from('schedules').delete().eq('id', id)
+  if (error) throw error
+}
+
+/**
+ * Replace all weekly schedules (day_of_week based) for an assignee.
+ * Deletes existing weekly entries and creates new ones in a single flow.
+ */
+export async function replaceWeeklySchedules(
+  assigneeId: string,
+  week: Record<number, { enabled: boolean; periods: { startsAt: string; endsAt: string; settings?: BlockSettings }[] }>,
+  kind = 'working_hours',
+): Promise<void> {
+  const core = getCoreClient()
+  const tenantId = getTenantId()
+
+  // Delete existing weekly schedules (day_of_week NOT NULL, specific_date IS NULL)
+  const { error: delErr } = await core
+    .from('schedules')
+    .delete()
+    .eq('assignee_id', assigneeId)
+    .eq('kind', kind)
+    .not('day_of_week', 'is', null)
+    .is('specific_date', null)
+
+  if (delErr) throw delErr
+
+  // Build insert rows
+  const rows: Record<string, unknown>[] = []
+  for (const [dayStr, day] of Object.entries(week)) {
+    if (!day.enabled) continue
+    for (const period of day.periods) {
+      const metadata = period.settings ? mergeBlockSettings({}, period.settings) : {}
+      rows.push({
+        tenant_id: tenantId,
+        kind,
+        assignee_id: assigneeId,
+        day_of_week: Number(dayStr),
+        specific_date: null,
+        starts_at: period.startsAt,
+        ends_at: period.endsAt,
+        is_active: true,
+        metadata,
+      })
+    }
+  }
+
+  if (rows.length > 0) {
+    const { error: insErr } = await core.from('schedules').insert(rows)
+    if (insErr) throw insErr
+  }
+}
+
+/**
+ * Enumerate all dates in a range (inclusive).
+ */
+function eachDate(startDate: string, endDate: string): string[] {
+  const dates: string[] = []
+  const current = new Date(startDate + 'T00:00:00Z')
+  const end = new Date(endDate + 'T00:00:00Z')
+  while (current <= end) {
+    dates.push(current.toISOString().slice(0, 10))
+    current.setUTCDate(current.getUTCDate() + 1)
+  }
+  return dates
+}
+
+/**
+ * Save a date-range exception.
+ * type: 'unavailable' marks days off, 'available' sets custom hours.
+ * Stores notes and range info in metadata for retrieval.
+ */
+export async function saveException(input: {
+  assigneeId: string
+  startDate: string
+  endDate: string
+  type: 'available' | 'unavailable'
+  periods: { startsAt: string; endsAt: string }[]
+  notes?: string
+  settings?: BlockSettings
+  kind?: string
+}): Promise<void> {
+  const core = getCoreClient()
+  const tenantId = getTenantId()
+  const kind = input.kind ?? 'working_hours'
+  const dates = eachDate(input.startDate, input.endDate)
+  const isRange = dates.length > 1
+  const meta = mergeBlockSettings(
+    {
+      ...(input.notes ? { notes: input.notes } : {}),
+      ...(isRange ? { rangeStart: input.startDate, rangeEnd: input.endDate } : {}),
+      exceptionType: input.type,
+    },
+    input.settings ?? {},
+  )
+
+  // Delete existing exceptions for all dates in range (single query)
+  const { error: delErr } = await core
+    .from('schedules')
+    .delete()
+    .eq('assignee_id', input.assigneeId)
+    .eq('kind', kind)
+    .in('specific_date', dates)
+  if (delErr) throw delErr
+
+  const rows: Record<string, unknown>[] = []
+
+  if (input.type === 'unavailable') {
+    // One sentinel row per date with is_active: false
+    for (const date of dates) {
+      rows.push({
+        tenant_id: tenantId,
+        kind,
+        assignee_id: input.assigneeId,
+        day_of_week: null,
+        specific_date: date,
+        starts_at: '00:00',
+        ends_at: '00:00',
+        is_active: false,
+        metadata: meta,
+      })
+    }
+  } else {
+    // Custom available hours for each date
+    for (const date of dates) {
+      for (const p of input.periods) {
+        rows.push({
+          tenant_id: tenantId,
+          kind,
+          assignee_id: input.assigneeId,
+          day_of_week: null,
+          specific_date: date,
+          starts_at: p.startsAt,
+          ends_at: p.endsAt,
+          is_active: true,
+          metadata: meta,
+        })
+      }
+    }
+  }
+
+  if (rows.length > 0) {
+    const { error } = await core.from('schedules').insert(rows)
+    if (error) throw error
+  }
+}
+
+/**
+ * Delete an exception by its start date.
+ * If it was part of a range, deletes all dates in that range.
+ */
+export async function deleteException(
+  assigneeId: string,
+  startDate: string,
+  endDate?: string,
+  kind = 'working_hours',
+): Promise<void> {
+  const core = getCoreClient()
+  const dates = eachDate(startDate, endDate ?? startDate)
+  const { error } = await core
+    .from('schedules')
+    .delete()
+    .eq('assignee_id', assigneeId)
+    .eq('kind', kind)
+    .in('specific_date', dates)
+  if (error) throw error
+}

package/src/shell/lib/supabase.ts

@@ -0,0 +1,19 @@
+// Shim → native Supabase client (unified singleton across shell + plugins).
+import type { SupabaseClient } from '@supabase/supabase-js'
+import { getSupabaseClientOptional as _getOpt } from '@fayz-ai/core'
+export { createSupabaseProvider, setGlobalSupabaseClient } from '@fayz-ai/core'
+// @fayz-ai/core returns a loosely-typed client (no hard supabase coupling); the
+// shell does `.schema(...).from(...)`, so surface it as the real client type.
+export const getSupabaseClientOptional = (): SupabaseClient | null =>
+  _getOpt() as unknown as SupabaseClient | null
+export {
+  CORE_SCHEMA,
+  getCoreSchemaClient as getCoreClient,
+  getFayzSupabaseClient as getSupabaseClient,
+  getFayzSupabaseClientOptional as getSupabaseClientSafe,
+  createFayzSupabaseClient as createSupabaseClient,
+} from '../../supabase/client'
+import { getFayzSupabaseClient } from '../../supabase/client'
+export const getCoreSupabaseClient = getFayzSupabaseClient
+export const getProjectSupabaseClient = getFayzSupabaseClient
+export type { SupabaseClient }

package/src/shell/stores/auth.store.ts

@@ -0,0 +1,29 @@
+import { create } from 'zustand'
+import type { AuthUser, AuthSession, AuthState } from '../types'
+
+interface AuthStore extends AuthState {
+  setUser: (user: AuthUser | null) => void
+  setSession: (session: AuthSession | null) => void
+  setLoading: (loading: boolean) => void
+  setInitialized: (initialized: boolean) => void
+  setPendingEmailVerification: (pending: boolean) => void
+  reset: () => void
+}
+
+const initialState: AuthState = {
+  user: null,
+  session: null,
+  loading: true,
+  initialized: false,
+  pendingEmailVerification: false,
+}
+
+export const useAuthStore = create<AuthStore>((set) => ({
+  ...initialState,
+  setUser: (user) => set({ user }),
+  setSession: (session) => set({ session, user: session?.user ?? null, pendingEmailVerification: false }),
+  setLoading: (loading) => set({ loading }),
+  setInitialized: (initialized) => set({ initialized }),
+  setPendingEmailVerification: (pendingEmailVerification) => set({ pendingEmailVerification }),
+  reset: () => set(initialState),
+}))

package/src/shell/stores/billing.store.ts

@@ -0,0 +1 @@
+export { useBillingStore } from '../../billing'

package/src/shell/stores/chat.store.ts

@@ -0,0 +1,45 @@
+import { create } from 'zustand'
+
+export interface ChatMessage {
+  id: string
+  role: 'user' | 'assistant'
+  content: string
+  timestamp: string
+}
+
+interface ChatState {
+  messages: ChatMessage[]
+  isOpen: boolean
+  isStreaming: boolean
+  setOpen: (open: boolean) => void
+  toggleOpen: () => void
+  addMessage: (message: ChatMessage) => void
+  updateLastAssistant: (content: string) => void
+  setStreaming: (streaming: boolean) => void
+  reset: () => void
+}
+
+export const useChatStore = create<ChatState>((set) => ({
+  messages: [],
+  isOpen: false,
+  isStreaming: false,
+
+  setOpen: (open) => set({ isOpen: open }),
+  toggleOpen: () => set((s) => ({ isOpen: !s.isOpen })),
+
+  addMessage: (message) =>
+    set((s) => ({ messages: [...s.messages, message] })),
+
+  updateLastAssistant: (content) =>
+    set((s) => {
+      const msgs = [...s.messages]
+      const lastIdx = msgs.length - 1
+      if (lastIdx >= 0 && msgs[lastIdx].role === 'assistant') {
+        msgs[lastIdx] = { ...msgs[lastIdx], content }
+      }
+      return { messages: msgs }
+    }),
+
+  setStreaming: (isStreaming) => set({ isStreaming }),
+  reset: () => set({ messages: [], isStreaming: false }),
+}))

package/src/shell/stores/index.ts

@@ -0,0 +1,12 @@
+export { useAuthStore } from './auth.store'
+export { useTenantStore } from './tenant.store'
+export { usePluginStore } from './plugin.store'
+export { useLayoutStore } from './layout.store'
+export { useThemeStore } from './theme.store'
+export { useBillingStore } from './billing.store'
+export { useNotificationStore } from './notifications.store'
+export { useLocaleStore } from './locale.store'
+export { useChatStore } from './chat.store'
+export { useOrganizationStore } from './organization.store'
+export { usePermissionsStore } from './permissions.store'
+export { useInviteStore } from './invite.store'

package/src/shell/stores/invite.store.ts

@@ -0,0 +1,18 @@
+import { create } from 'zustand'
+import type { Invite } from '../types/invite'
+
+interface InviteStore {
+  invites: Invite[]
+  loading: boolean
+  setInvites: (invites: Invite[]) => void
+  setLoading: (loading: boolean) => void
+  reset: () => void
+}
+
+export const useInviteStore = create<InviteStore>((set) => ({
+  invites: [],
+  loading: false,
+  setInvites: (invites) => set({ invites }),
+  setLoading: (loading) => set({ loading }),
+  reset: () => set({ invites: [], loading: false }),
+}))

package/src/shell/stores/layout.store.ts

@@ -0,0 +1 @@
+export { useLayoutStore } from '@fayz-ai/ui'

package/src/shell/stores/locale.store.ts

@@ -0,0 +1,24 @@
+import { create } from 'zustand'
+
+const STORAGE_KEY = 'saas-core:locale'
+
+function getPersistedLocale(): string {
+  try {
+    return localStorage.getItem(STORAGE_KEY) ?? 'en'
+  } catch {
+    return 'en'
+  }
+}
+
+interface LocaleState {
+  locale: string
+  setLocale: (locale: string) => void
+}
+
+export const useLocaleStore = create<LocaleState>((set) => ({
+  locale: getPersistedLocale(),
+  setLocale: (locale) => {
+    try { localStorage.setItem(STORAGE_KEY, locale) } catch { /* ignore */ }
+    set({ locale })
+  },
+}))

package/src/shell/stores/location.store.ts

@@ -0,0 +1,89 @@
+import { create } from 'zustand'
+import type { Location } from '../types/tenant'
+
+const STORAGE_KEY = 'saas-core:current-location'
+
+interface LocationStore {
+  /** All org locations (active + inactive) */
+  locations: Location[]
+  /** Currently selected location (session-scoped) */
+  currentLocation: Location | null
+  loading: boolean
+  /** True while the full-page switch overlay is visible */
+  switching: boolean
+
+  setLocations: (locations: Location[]) => void
+  setCurrentLocation: (location: Location | null) => void
+  /** Switch with full-page overlay + page reload */
+  switchLocation: (location: Location) => void
+  setLoading: (loading: boolean) => void
+  reset: () => void
+}
+
+function getPersistedLocationId(): string | null {
+  try {
+    return localStorage.getItem(STORAGE_KEY)
+  } catch {
+    return null
+  }
+}
+
+function persistLocationId(id: string | null) {
+  try {
+    if (id) {
+      localStorage.setItem(STORAGE_KEY, id)
+    } else {
+      localStorage.removeItem(STORAGE_KEY)
+    }
+  } catch {
+    // ignore
+  }
+}
+
+export const useLocationStore = create<LocationStore>((set, get) => ({
+  locations: [],
+  currentLocation: null,
+  loading: false,
+  switching: false,
+
+  setLocations: (locations) => {
+    const persistedId = getPersistedLocationId()
+    const active = locations.filter((l) => l.isActive)
+
+    // Auto-select: persisted → HQ → first active
+    let selected: Location | null = null
+    if (persistedId) {
+      selected = active.find((l) => l.id === persistedId) ?? null
+    }
+    if (!selected) {
+      selected = active.find((l) => l.isHeadquarters) ?? active[0] ?? null
+    }
+
+    set({ locations, currentLocation: selected })
+    if (selected) persistLocationId(selected.id)
+  },
+
+  setCurrentLocation: (location) => {
+    persistLocationId(location?.id ?? null)
+    set({ currentLocation: location })
+  },
+
+  switchLocation: (location) => {
+    if (location.id === get().currentLocation?.id) return
+    set({ switching: true })
+    persistLocationId(location.id)
+    // Let the overlay animate in, then reload
+    setTimeout(() => {
+      window.location.reload()
+    }, 900)
+  },
+
+  setLoading: (loading) => set({ loading }),
+
+  reset: () => {
+    persistLocationId(null)
+    set({ locations: [], currentLocation: null, loading: false, switching: false })
+  },
+}))
+
+export { getPersistedLocationId }

package/src/shell/stores/notifications.store.ts

@@ -0,0 +1,48 @@
+import { create } from 'zustand'
+import type { Notification, NotificationState } from '../types'
+
+interface NotificationStore extends NotificationState {
+  setNotifications: (notifications: Notification[]) => void
+  addNotification: (notification: Notification) => void
+  markRead: (id: string) => void
+  markAllRead: () => void
+  setLoading: (loading: boolean) => void
+  reset: () => void
+}
+
+const initialState: NotificationState = {
+  notifications: [],
+  unreadCount: 0,
+  loading: false,
+}
+
+export const useNotificationStore = create<NotificationStore>((set) => ({
+  ...initialState,
+  setNotifications: (notifications) =>
+    set({
+      notifications,
+      unreadCount: notifications.filter((n) => !n.read).length,
+    }),
+  addNotification: (notification) =>
+    set((state) => ({
+      notifications: [notification, ...state.notifications],
+      unreadCount: state.unreadCount + (notification.read ? 0 : 1),
+    })),
+  markRead: (id) =>
+    set((state) => {
+      const notifications = state.notifications.map((n) =>
+        n.id === id ? { ...n, read: true } : n
+      )
+      return {
+        notifications,
+        unreadCount: notifications.filter((n) => !n.read).length,
+      }
+    }),
+  markAllRead: () =>
+    set((state) => ({
+      notifications: state.notifications.map((n) => ({ ...n, read: true })),
+      unreadCount: 0,
+    })),
+  setLoading: (loading) => set({ loading }),
+  reset: () => set(initialState),
+}))

package/src/shell/stores/organization.store.ts

@@ -0,0 +1,3 @@
+// Shim → native org store (unified singleton). The legacy shell + native code
+// (plugins, CRUD) now read the same organization store.
+export { useOrganizationStore, getPersistedOrgId } from '../../org'

package/src/shell/stores/permissions.store.ts

@@ -0,0 +1 @@
+export { usePermissionsStore } from '../../permissions'

package/src/shell/stores/plugin.store.ts

@@ -0,0 +1,50 @@
+import { create } from 'zustand'
+import type { TenantPluginBinding } from '../types/plugins'
+
+export interface ActiveTenantPluginRecord {
+  pluginId: string
+  name?: string
+  version?: string
+  scope?: string
+  manifest?: Record<string, unknown>
+  config: Record<string, unknown>
+  enabledAt?: string
+}
+
+interface PluginStore {
+  tenantId: string | null
+  tenantPlugins: TenantPluginBinding[]
+  activePlugins: ActiveTenantPluginRecord[]
+  loading: boolean
+  error: string | null
+  setTenantPlugins: (tenantId: string, activePlugins: ActiveTenantPluginRecord[]) => void
+  setLoading: (loading: boolean) => void
+  setError: (error: string | null) => void
+  reset: () => void
+}
+
+const initialState = {
+  tenantId: null,
+  tenantPlugins: [],
+  activePlugins: [],
+  loading: false,
+  error: null,
+}
+
+export const usePluginStore = create<PluginStore>((set) => ({
+  ...initialState,
+  setTenantPlugins: (tenantId, activePlugins) => set({
+    tenantId,
+    activePlugins,
+    tenantPlugins: activePlugins.map((plugin) => ({
+      pluginId: plugin.pluginId,
+      status: 'active',
+      tenantId,
+      config: plugin.config,
+    })),
+    error: null,
+  }),
+  setLoading: (loading) => set({ loading }),
+  setError: (error) => set({ error }),
+  reset: () => set(initialState),
+}))

package/src/shell/stores/tenant.store.ts

@@ -0,0 +1,26 @@
+import { create } from 'zustand'
+import type { Tenant, TenantMember, MemberRole, TenantState } from '../types'
+
+interface TenantStore extends TenantState {
+  setTenant: (tenant: Tenant | null) => void
+  setMembers: (members: TenantMember[]) => void
+  setCurrentRole: (role: MemberRole | null) => void
+  setLoading: (loading: boolean) => void
+  reset: () => void
+}
+
+const initialState: TenantState = {
+  tenant: null,
+  members: [],
+  currentRole: null,
+  loading: false,
+}
+
+export const useTenantStore = create<TenantStore>((set) => ({
+  ...initialState,
+  setTenant: (tenant) => set({ tenant }),
+  setMembers: (members) => set({ members }),
+  setCurrentRole: (role) => set({ currentRole: role }),
+  setLoading: (loading) => set({ loading }),
+  reset: () => set(initialState),
+}))