@fayz-ai/saas 0.1.6

package/src/lib/schedule-service.ts

@@ -0,0 +1,307 @@
+// ---------------------------------------------------------------------------
+// Standalone Schedule CRUD Service
+// Works outside the agenda plugin context — uses Supabase directly.
+// ---------------------------------------------------------------------------
+
+import { getCoreSchemaClient as getCoreClient } from '../supabase/client'
+import { useOrganizationStore } from '../org'
+
+// ---------------------------------------------------------------------------
+// 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/org/adapters/mock.ts

@@ -0,0 +1,353 @@
+import type {
+  OrgAdapter,
+  Organization,
+  OrgMember,
+  OrgMembership,
+  CreateOrgOptions,
+  Location,
+  Invite,
+} from '@fayz-ai/core'
+import type { PermissionProfile } from '@fayz-ai/core'
+
+const STORAGE_KEY = 'fayz:mock-orgs'
+
+interface MockOrgData {
+  orgs: Organization[]
+  members: OrgMember[]
+  profiles: Record<string, PermissionProfile[]>
+  invites: Record<string, Invite[]>
+  userOrgMap: Record<string, string[]>
+}
+
+function getStored(): MockOrgData {
+  try {
+    if (typeof localStorage === 'undefined') return empty()
+    const raw = localStorage.getItem(STORAGE_KEY)
+    if (raw) return JSON.parse(raw) as MockOrgData
+  } catch {
+    // ignore
+  }
+  return empty()
+}
+
+function empty(): MockOrgData {
+  return { orgs: [], members: [], profiles: {}, invites: {}, userOrgMap: {} }
+}
+
+function setStored(data: MockOrgData): void {
+  try {
+    if (typeof localStorage === 'undefined') return
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(data))
+  } catch {
+    // ignore
+  }
+}
+
+function slugify(name: string): string {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+}
+
+export function createMockOrgAdapter(defaultProfiles?: PermissionProfile[]): OrgAdapter {
+  function seedOrgForUser(userId: string, userName?: string): MockOrgData {
+    const data = getStored()
+    if (data.userOrgMap[userId]?.length) return data
+
+    const orgId = crypto.randomUUID()
+    const memberId = crypto.randomUUID()
+    const firstProfile = defaultProfiles?.[0]
+
+    const org: Organization = {
+      id: orgId,
+      name: 'My Organization',
+      slug: 'my-organization',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }
+
+    const member: OrgMember = {
+      id: memberId,
+      userId,
+      orgId,
+      profileId: firstProfile?.id ?? 'owner',
+      profileName: firstProfile?.name ?? 'Owner',
+      user: {
+        id: userId,
+        email: userName
+          ? `${userName.toLowerCase().replace(/\s+/g, '.')}@example.com`
+          : 'user@example.com',
+        fullName: userName ?? 'Current User',
+      },
+      joinedAt: new Date().toISOString(),
+    }
+
+    data.orgs.push(org)
+    data.members.push(member)
+    data.userOrgMap[userId] = [orgId]
+    if (defaultProfiles) {
+      data.profiles[orgId] = [...defaultProfiles]
+    }
+    data.invites[orgId] = []
+
+    setStored(data)
+    return data
+  }
+
+  return {
+    async listUserOrgs(userId: string): Promise<OrgMembership[]> {
+      const data = seedOrgForUser(userId)
+      const orgIds = data.userOrgMap[userId] ?? []
+      return orgIds.map((orgId) => {
+        const org = data.orgs.find((o) => o.id === orgId)!
+        const member = data.members.find((m) => m.orgId === orgId && m.userId === userId)
+        return {
+          orgId,
+          orgName: org.name,
+          orgSlug: org.slug,
+          orgLogoUrl: org.logoUrl,
+          profileId: member?.profileId ?? 'owner',
+          profileName: member?.profileName ?? 'Owner',
+        }
+      })
+    },
+
+    async getOrg(orgId: string): Promise<Organization> {
+      const data = getStored()
+      const org = data.orgs.find((o) => o.id === orgId)
+      if (!org) throw new Error(`Org not found: ${orgId}`)
+      return org
+    },
+
+    async createOrg(name: string, userId: string, options?: CreateOrgOptions): Promise<Organization> {
+      const data = getStored()
+      const orgId = crypto.randomUUID()
+      const firstProfile = defaultProfiles?.[0]
+
+      const org: Organization = {
+        id: orgId,
+        name,
+        slug: slugify(name),
+        verticalId: options?.verticalId,
+        plan: 'free',
+        settings: {
+          timezone: options?.timezone ?? 'America/Sao_Paulo',
+          currency: options?.currency ?? 'BRL',
+          locale: options?.locale ?? 'pt-BR',
+        },
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+
+      const member: OrgMember = {
+        id: crypto.randomUUID(),
+        userId,
+        orgId,
+        profileId: firstProfile?.id ?? 'owner',
+        profileName: firstProfile?.name ?? 'Owner',
+        user: {
+          id: userId,
+          email: 'user@example.com',
+          fullName: 'Current User',
+        },
+        joinedAt: new Date().toISOString(),
+      }
+
+      data.orgs.push(org)
+      data.members.push(member)
+      if (!data.userOrgMap[userId]) data.userOrgMap[userId] = []
+      data.userOrgMap[userId].push(orgId)
+      if (defaultProfiles) {
+        data.profiles[orgId] = [...defaultProfiles]
+      }
+      data.invites[orgId] = []
+
+      setStored(data)
+      return org
+    },
+
+    async updateOrg(orgId: string, updates: Partial<Organization>): Promise<Organization> {
+      const data = getStored()
+      const idx = data.orgs.findIndex((o) => o.id === orgId)
+      if (idx === -1) throw new Error(`Org not found: ${orgId}`)
+      data.orgs[idx] = { ...data.orgs[idx], ...updates, updatedAt: new Date().toISOString() }
+      setStored(data)
+      return data.orgs[idx]
+    },
+
+    async listMembers(orgId: string): Promise<OrgMember[]> {
+      const data = getStored()
+      return data.members.filter((m) => m.orgId === orgId)
+    },
+
+    async updateMemberProfile(orgId: string, memberId: string, profileId: string): Promise<void> {
+      const data = getStored()
+      const member = data.members.find((m) => m.id === memberId && m.orgId === orgId)
+      if (!member) throw new Error(`Member not found: ${memberId}`)
+      const profiles = data.profiles[orgId] ?? []
+      const profile = profiles.find((p) => p.id === profileId)
+      member.profileId = profileId
+      member.profileName = profile?.name ?? profileId
+      setStored(data)
+    },
+
+    async removeMember(orgId: string, memberId: string): Promise<void> {
+      const data = getStored()
+      const memberIdx = data.members.findIndex((m) => m.id === memberId && m.orgId === orgId)
+      if (memberIdx === -1) return
+      const member = data.members[memberIdx]
+      data.members.splice(memberIdx, 1)
+      const userOrgs = data.userOrgMap[member.userId]
+      if (userOrgs) {
+        const orgIdx = userOrgs.indexOf(orgId)
+        if (orgIdx !== -1) userOrgs.splice(orgIdx, 1)
+      }
+      setStored(data)
+    },
+
+    async listProfiles(orgId: string): Promise<PermissionProfile[]> {
+      const data = getStored()
+      return data.profiles[orgId] ?? defaultProfiles ?? []
+    },
+
+    async createProfile(
+      orgId: string,
+      profile: Omit<PermissionProfile, 'id' | 'isSystem'>,
+    ): Promise<PermissionProfile> {
+      const data = getStored()
+      const newProfile: PermissionProfile = {
+        ...profile,
+        id: crypto.randomUUID(),
+        isSystem: false,
+      }
+      if (!data.profiles[orgId]) {
+        data.profiles[orgId] = defaultProfiles ? [...defaultProfiles] : []
+      }
+      data.profiles[orgId].push(newProfile)
+      setStored(data)
+      return newProfile
+    },
+
+    async updateProfile(
+      orgId: string,
+      profileId: string,
+      updates: Partial<PermissionProfile>,
+    ): Promise<PermissionProfile> {
+      const data = getStored()
+      const profiles = data.profiles[orgId] ?? []
+      const idx = profiles.findIndex((p) => p.id === profileId)
+      if (idx === -1) throw new Error(`Profile not found: ${profileId}`)
+      profiles[idx] = { ...profiles[idx], ...updates }
+      data.profiles[orgId] = profiles
+      setStored(data)
+      return profiles[idx]
+    },
+
+    async deleteProfile(orgId: string, profileId: string): Promise<void> {
+      const data = getStored()
+      const profiles = data.profiles[orgId] ?? []
+      const profile = profiles.find((p) => p.id === profileId)
+      if (profile?.isSystem) throw new Error('Cannot delete system profile')
+      data.profiles[orgId] = profiles.filter((p) => p.id !== profileId)
+      setStored(data)
+    },
+
+    async listInvites(orgId: string): Promise<Invite[]> {
+      const data = getStored()
+      return data.invites[orgId] ?? []
+    },
+
+    async createInvite(
+      orgId: string,
+      email: string,
+      profileId: string,
+      invitedBy: string,
+    ): Promise<Invite> {
+      const data = getStored()
+      const profiles = data.profiles[orgId] ?? defaultProfiles ?? []
+      const profile = profiles.find((p) => p.id === profileId)
+
+      const invite: Invite = {
+        id: crypto.randomUUID(),
+        orgId,
+        email,
+        profileId,
+        profileName: profile?.name ?? profileId,
+        invitedBy,
+        token: crypto.randomUUID(),
+        status: 'pending',
+        createdAt: new Date().toISOString(),
+        expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+      }
+
+      if (!data.invites[orgId]) data.invites[orgId] = []
+      data.invites[orgId].push(invite)
+      setStored(data)
+      return invite
+    },
+
+    async bulkInvite(
+      orgId: string,
+      emails: string[],
+      profileId: string,
+      invitedBy: string,
+    ): Promise<Invite[]> {
+      const results: Invite[] = []
+      for (const email of emails) {
+        results.push(await this.createInvite(orgId, email, profileId, invitedBy))
+      }
+      return results
+    },
+
+    async revokeInvite(orgId: string, inviteId: string): Promise<void> {
+      const data = getStored()
+      const invites = data.invites[orgId] ?? []
+      const invite = invites.find((i) => i.id === inviteId)
+      if (invite) {
+        invite.status = 'expired'
+        setStored(data)
+      }
+    },
+
+    async resendInvite(orgId: string, inviteId: string): Promise<Invite> {
+      const data = getStored()
+      const invites = data.invites[orgId] ?? []
+      const invite = invites.find((i) => i.id === inviteId)
+      if (!invite) throw new Error(`Invite not found: ${inviteId}`)
+      invite.expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString()
+      invite.status = 'pending'
+      setStored(data)
+      return invite
+    },
+
+    async listLocations(_orgId: string): Promise<Location[]> {
+      return []
+    },
+
+    async createLocation(
+      orgId: string,
+      input: {
+        name: string
+        address?: string
+        city?: string
+        state?: string
+        country?: string
+        phone?: string
+        isHeadquarters?: boolean
+      },
+    ): Promise<Location> {
+      return {
+        id: crypto.randomUUID(),
+        tenantId: orgId,
+        name: input.name,
+        address: input.address,
+        city: input.city,
+        state: input.state,
+        country: input.country ?? 'BR',
+        phone: input.phone,
+        isHeadquarters: input.isHeadquarters ?? false,
+        isActive: true,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      }
+    },
+  }
+}