@fayz-ai/sdk 0.9.0-next.1 → 0.10.0

package/src/runtime.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import {
-  createFayzRuntimeClient,
-  FayzRuntimeError,
-} from './runtime'
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { 'Content-Type': 'application/json' },
-  })
-}
-
-describe('createFayzRuntimeClient', () => {
-  it('exchanges runtime-data tokens for broker tokens without sending provider credentials', async () => {
-    const fetcher = vi.fn<typeof fetch>().mockResolvedValue(jsonResponse({
-      token: 'broker-token',
-      tokenType: 'Bearer',
-      expiresIn: 300,
-      projectId: 'project-1',
-      tenantKey: 'tenant-a',
-      environment: 'preview',
-      pluginId: '@fayz-ai/plugin-agenda',
-      grants: [{ grantId: 'grant-1', provider: 'google-calendar', scopes: ['calendar.read'] }],
-    }))
-    const client = createFayzRuntimeClient({
-      baseUrl: 'https://api.fayz.ai/',
-      projectId: 'project-1',
-      runtimeToken: 'runtime-token',
-      fetcher,
-    })
-
-    const response = await client.exchangePluginOAuth({
-      pluginId: '@fayz-ai/plugin-agenda',
-      scopes: ['calendar.read'],
-    })
-
-    expect(response.token).toBe('broker-token')
-    expect(fetcher).toHaveBeenCalledWith(
-      'https://api.fayz.ai/api/v1/runtime/projects/project-1/oauth/exchange',
-      expect.objectContaining({
-        method: 'POST',
-        headers: expect.objectContaining({
-          Authorization: 'Bearer runtime-token',
-          'Content-Type': 'application/json',
-        }),
-        body: JSON.stringify({
-          pluginId: '@fayz-ai/plugin-agenda',
-          environment: 'preview',
-          scopes: ['calendar.read'],
-        }),
-      }),
-    )
-    expect(JSON.stringify(fetcher.mock.calls)).not.toContain('clientSecret')
-    expect(JSON.stringify(fetcher.mock.calls)).not.toContain('refreshToken')
-    expect(JSON.stringify(fetcher.mock.calls)).not.toContain('accessToken')
-  })
-
-  it('calls Google Calendar broker routes with the short-lived plugin OAuth token', async () => {
-    const fetcher = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({ provider: 'google-calendar', calendarId: 'primary', events: [] }))
-      .mockResolvedValueOnce(jsonResponse({ provider: 'google-calendar', calendarId: 'primary', event: { id: 'event-1' } }, 201))
-      .mockResolvedValueOnce(jsonResponse({ provider: 'google-calendar', calendarId: 'primary', event: { id: 'event-1' } }))
-      .mockResolvedValueOnce(new Response(null, { status: 204 }))
-    const client = createFayzRuntimeClient({
-      baseUrl: 'https://api.fayz.ai',
-      projectId: 'project-1',
-      runtimeToken: 'runtime-token',
-      fetcher,
-    })
-    const calendar = client.googleCalendar('broker-token')
-
-    await calendar.listEvents({
-      calendarId: 'primary',
-      timeMin: '2026-06-14T00:00:00.000Z',
-      timeMax: '2026-06-15T00:00:00.000Z',
-      maxResults: 25,
-    })
-    await calendar.createEvent('primary', {
-      summary: 'Haircut',
-      start: { dateTime: '2026-06-14T09:00:00.000Z' },
-      end: { dateTime: '2026-06-14T09:30:00.000Z' },
-    })
-    await calendar.updateEvent('primary', 'event-1', { summary: 'Updated haircut' })
-    await calendar.deleteEvent('primary', 'event-1')
-
-    expect(fetcher.mock.calls[0][0]).toBe(
-      'https://api.fayz.ai/api/v1/runtime/projects/project-1/oauth/google-calendar/events?calendarId=primary&timeMin=2026-06-14T00%3A00%3A00.000Z&timeMax=2026-06-15T00%3A00%3A00.000Z&maxResults=25',
-    )
-    expect(fetcher.mock.calls[1][0]).toBe(
-      'https://api.fayz.ai/api/v1/runtime/projects/project-1/oauth/google-calendar/events?calendarId=primary',
-    )
-    expect(fetcher.mock.calls[2][0]).toBe(
-      'https://api.fayz.ai/api/v1/runtime/projects/project-1/oauth/google-calendar/events/event-1?calendarId=primary',
-    )
-    expect(fetcher.mock.calls[3][0]).toBe(
-      'https://api.fayz.ai/api/v1/runtime/projects/project-1/oauth/google-calendar/events/event-1?calendarId=primary',
-    )
-    expect(fetcher.mock.calls[0][1]).toEqual(expect.objectContaining({
-      headers: expect.objectContaining({ Authorization: 'Bearer broker-token' }),
-    }))
-    expect(fetcher.mock.calls[1][1]).toEqual(expect.objectContaining({ method: 'POST' }))
-    expect(fetcher.mock.calls[2][1]).toEqual(expect.objectContaining({ method: 'PATCH' }))
-    expect(fetcher.mock.calls[3][1]).toEqual(expect.objectContaining({ method: 'DELETE' }))
-  })
-
-  it('keeps non-json upstream errors debuggable', async () => {
-    const fetcher = vi.fn<typeof fetch>().mockResolvedValue(new Response('upstream unavailable', { status: 502 }))
-    const client = createFayzRuntimeClient({
-      baseUrl: 'https://api.fayz.ai',
-      projectId: 'project-1',
-      runtimeToken: 'runtime-token',
-      fetcher,
-    })
-
-    await expect(client.exchangePluginOAuth({ pluginId: '@fayz-ai/plugin-agenda' }))
-      .rejects.toMatchObject({
-        name: 'FayzRuntimeError',
-        status: 502,
-        responseBody: 'upstream unavailable',
-      } satisfies Partial<FayzRuntimeError>)
-  })
-})

package/src/runtime.ts

@@ -1,211 +0,0 @@
-export interface FayzRuntimeClientOptions {
-  baseUrl: string
-  projectId: string
-  runtimeToken: string
-  fetcher?: typeof fetch
-}
-
-export type FayzRuntimeEnvironment = 'preview' | 'production'
-
-export interface PluginOAuthExchangeInput {
-  pluginId: string
-  environment?: FayzRuntimeEnvironment
-  scopes?: string[]
-}
-
-export interface RuntimePluginOAuthGrant {
-  grantId: string
-  provider: string
-  scopes: string[]
-}
-
-export interface PluginOAuthExchangeResponse {
-  token: string
-  tokenType: 'Bearer'
-  expiresIn: number
-  projectId: string
-  tenantKey: string
-  environment: FayzRuntimeEnvironment
-  pluginId: string
-  grants: RuntimePluginOAuthGrant[]
-}
-
-export interface GoogleCalendarEventTime {
-  dateTime: string
-  timeZone?: string
-}
-
-export interface GoogleCalendarEventInput {
-  summary: string
-  description?: string
-  location?: string
-  start: GoogleCalendarEventTime
-  end: GoogleCalendarEventTime
-  attendees?: Array<{ email: string }>
-}
-
-export interface GoogleCalendarEvent {
-  id: string
-  summary?: string
-  description?: string
-  location?: string
-  start: { dateTime?: string; date?: string; timeZone?: string }
-  end: { dateTime?: string; date?: string; timeZone?: string }
-  status?: string
-  htmlLink?: string
-  [key: string]: unknown
-}
-
-export interface ListGoogleCalendarEventsInput {
-  calendarId: string
-  timeMin?: string
-  timeMax?: string
-  maxResults?: number
-  q?: string
-}
-
-export class FayzRuntimeError extends Error {
-  constructor(
-    message: string,
-    readonly status: number,
-    readonly responseBody?: unknown,
-  ) {
-    super(message)
-    this.name = 'FayzRuntimeError'
-  }
-}
-
-function normalizeBaseUrl(baseUrl: string): string {
-  return baseUrl.replace(/\/+$/, '')
-}
-
-function assertRequired(value: string, field: string): string {
-  const normalized = value.trim()
-  if (!normalized) throw new Error(`${field} is required`)
-  return normalized
-}
-
-function runtimePath(projectId: string, suffix: string): string {
-  return `/api/v1/runtime/projects/${encodeURIComponent(projectId)}${suffix}`
-}
-
-function queryString(params: Record<string, string | number | undefined>): string {
-  const search = new URLSearchParams()
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== undefined && value !== '') search.set(key, String(value))
-  }
-  const value = search.toString()
-  return value ? `?${value}` : ''
-}
-
-async function parseResponse<T>(response: Response): Promise<T> {
-  if (response.status === 204) return undefined as T
-
-  const text = await response.text()
-  let body: unknown
-  try {
-    body = text ? JSON.parse(text) : undefined
-  } catch {
-    body = text
-  }
-
-  if (!response.ok) {
-    const message = typeof body === 'object' && body && 'message' in body
-      ? String((body as { message: unknown }).message)
-      : `Fayz runtime request failed with status ${response.status}`
-    throw new FayzRuntimeError(message, response.status, body)
-  }
-
-  return body as T
-}
-
-export function createFayzRuntimeClient(options: FayzRuntimeClientOptions) {
-  const baseUrl = normalizeBaseUrl(assertRequired(options.baseUrl, 'baseUrl'))
-  const projectId = assertRequired(options.projectId, 'projectId')
-  const runtimeToken = assertRequired(options.runtimeToken, 'runtimeToken')
-  const fetcher = options.fetcher ?? fetch
-
-  async function request<T>(
-    path: string,
-    token: string,
-    init: Omit<RequestInit, 'headers'> & { headers?: Record<string, string> } = {},
-  ): Promise<T> {
-    const response = await fetcher(`${baseUrl}${path}`, {
-      ...init,
-      headers: {
-        ...(init.body ? { 'Content-Type': 'application/json' } : {}),
-        ...init.headers,
-        Authorization: `Bearer ${token}`,
-      },
-    })
-    return parseResponse<T>(response)
-  }
-
-  async function exchangePluginOAuth(input: PluginOAuthExchangeInput): Promise<PluginOAuthExchangeResponse> {
-    return request<PluginOAuthExchangeResponse>(
-      runtimePath(projectId, '/oauth/exchange'),
-      runtimeToken,
-      {
-        method: 'POST',
-        body: JSON.stringify({
-          pluginId: input.pluginId,
-          environment: input.environment ?? 'preview',
-          ...(input.scopes ? { scopes: input.scopes } : {}),
-        }),
-      },
-    )
-  }
-
-  function googleCalendar(pluginOAuthToken: string) {
-    const brokerToken = assertRequired(pluginOAuthToken, 'pluginOAuthToken')
-    const eventsPath = runtimePath(projectId, '/oauth/google-calendar/events')
-
-    return {
-      listEvents(input: ListGoogleCalendarEventsInput) {
-        const calendarId = assertRequired(input.calendarId, 'calendarId')
-        return request<{
-          provider: 'google-calendar'
-          calendarId: string
-          timeMin: string
-          timeMax: string
-          events: GoogleCalendarEvent[]
-        }>(
-          `${eventsPath}${queryString({
-            calendarId,
-            timeMin: input.timeMin,
-            timeMax: input.timeMax,
-            maxResults: input.maxResults,
-            q: input.q,
-          })}`,
-          brokerToken,
-        )
-      },
-      createEvent(calendarId: string, event: GoogleCalendarEventInput) {
-        return request<{ provider: 'google-calendar'; calendarId: string; event: GoogleCalendarEvent }>(
-          `${eventsPath}${queryString({ calendarId: assertRequired(calendarId, 'calendarId') })}`,
-          brokerToken,
-          { method: 'POST', body: JSON.stringify(event) },
-        )
-      },
-      updateEvent(calendarId: string, eventId: string, updates: Partial<GoogleCalendarEventInput>) {
-        return request<{ provider: 'google-calendar'; calendarId: string; event: GoogleCalendarEvent }>(
-          `${eventsPath}/${encodeURIComponent(assertRequired(eventId, 'eventId'))}${queryString({ calendarId: assertRequired(calendarId, 'calendarId') })}`,
-          brokerToken,
-          { method: 'PATCH', body: JSON.stringify(updates) },
-        )
-      },
-      deleteEvent(calendarId: string, eventId: string) {
-        return request<void>(
-          `${eventsPath}/${encodeURIComponent(assertRequired(eventId, 'eventId'))}${queryString({ calendarId: assertRequired(calendarId, 'calendarId') })}`,
-          brokerToken,
-          { method: 'DELETE' },
-        )
-      },
-    }
-  }
-
-  return {
-    exchangePluginOAuth,
-    googleCalendar,
-  }
-}

package/src/shop.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { createFayzShopProvider } from './shop'
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { 'Content-Type': 'application/json' },
-  })
-}
-
-function productRow(overrides: Record<string, unknown> = {}) {
-  return {
-    id: '11111111-1111-4111-8111-000000000001',
-    tenant_id: 'store-1',
-    name: 'Runner Vortex Neon',
-    slug: 'runner-vortex-neon',
-    sku: 'SNK-001',
-    price: 499.9,
-    metadata: {},
-    images: [],
-    ...overrides,
-  }
-}
-
-describe('createFayzShopProvider', () => {
-  it('uses the Fayz broker without provider credentials when apiBaseUrl and projectId are provided', async () => {
-    const fetcher = vi.fn<typeof fetch>().mockResolvedValue(jsonResponse({
-      products: [{
-        id: '11111111-1111-4111-8111-000000000001',
-        tenantId: 'store-1',
-        name: 'Aurora Tote',
-        slug: 'aurora-tote',
-        sku: 'BAG-001',
-        price: 149.9,
-        metadata: {},
-        images: [],
-        category: { id: 'cat-1', name: 'Bags' },
-      }],
-    }))
-
-    const provider = createFayzShopProvider({
-      apiBaseUrl: 'http://localhost:5173/api',
-      projectId: 'project-1',
-      fetcher,
-    })
-
-    const [product] = await provider.listProducts({ status: 'active', limit: 4 })
-
-    expect(fetcher).toHaveBeenCalledWith(
-      'http://localhost:5173/api/public/projects/project-1/shop/products?status=active&limit=4',
-      {},
-    )
-    expect(product?.categoryId).toBe('cat-1')
-    expect(product?.categoryName).toBe('Bags')
-  })
-
-  it('merges app-owned product metadata overlays into listed products', async () => {
-    const fetcher = vi.fn<typeof fetch>().mockResolvedValue(jsonResponse([
-      productRow({
-        metadata: {
-          colorway: 'Backend wins',
-        },
-      }),
-    ]))
-
-    const provider = createFayzShopProvider({
-      supabaseUrl: 'https://example.supabase.co',
-      publishableKey: 'publishable-key',
-      storeId: 'store-1',
-      productMetadata: [
-        {
-          sku: 'SNK-001',
-          slug: 'runner-vortex-neon',
-          metadata: {
-            colorway: 'Overlay loses',
-            sizes: ['38', '39', '40'],
-          },
-        },
-      ],
-      fetcher,
-    })
-
-    const [product] = await provider.listProducts({ status: 'active' })
-
-    expect(product?.metadata.sizes).toEqual(['38', '39', '40'])
-    expect(product?.metadata.colorway).toBe('Backend wins')
-  })
-
-  it('uses slug overlays when fetching a single product', async () => {
-    const fetcher = vi.fn<typeof fetch>().mockResolvedValue(jsonResponse([
-      productRow({ sku: null }),
-    ]))
-
-    const provider = createFayzShopProvider({
-      supabaseUrl: 'https://example.supabase.co',
-      publishableKey: 'publishable-key',
-      storeId: 'store-1',
-      productMetadata: [
-        {
-          slug: 'runner-vortex-neon',
-          metadata: {
-            sizes: ['40', '41'],
-          },
-        },
-      ],
-      fetcher,
-    })
-
-    const product = await provider.getProduct('11111111-1111-4111-8111-000000000001')
-
-    expect(product?.metadata.sizes).toEqual(['40', '41'])
-  })
-})