@symbo.ls/fetch 3.6.4 → 3.6.7

package/adapters/local.js

@@ -0,0 +1,148 @@
+'use strict'
+
+const matchesParams = (item, params) => {
+  if (!params) return true
+  for (const key in params) {
+    const val = params[key]
+    if (val === null) {
+      if (item[key] !== null && item[key] !== undefined) return false
+    } else if (Array.isArray(val)) {
+      if (!val.includes(item[key])) return false
+    } else if (typeof val === 'object') {
+      for (const op in val) {
+        if (op === 'gt' && !(item[key] > val[op])) return false
+        if (op === 'gte' && !(item[key] >= val[op])) return false
+        if (op === 'lt' && !(item[key] < val[op])) return false
+        if (op === 'lte' && !(item[key] <= val[op])) return false
+        if (op === 'neq' && item[key] === val[op]) return false
+        if (op === 'like' && !String(item[key]).includes(val[op])) return false
+      }
+    } else if (item[key] !== val) {
+      return false
+    }
+  }
+  return true
+}
+
+const applyModifiers = (items, { order, limit, offset, single }) => {
+  let result = [...items]
+
+  if (order) {
+    const by = typeof order === 'string' ? order : order.by
+    const asc = order.asc !== false
+    result.sort((a, b) => {
+      if (a[by] < b[by]) return asc ? -1 : 1
+      if (a[by] > b[by]) return asc ? 1 : -1
+      return 0
+    })
+  }
+
+  if (offset) result = result.slice(offset)
+  if (limit) result = result.slice(0, limit)
+  if (single) return { data: result[0] || null, error: null }
+
+  return { data: result, error: null }
+}
+
+export const setup = async ({ data, ...options }) => localAdapter(data, options)
+
+export const localAdapter = (initialData = {}, options = {}) => {
+  const store = {}
+  const listeners = {}
+  const persist = options.persist !== false && typeof localStorage !== 'undefined'
+  const prefix = options.prefix || 'smbls_db_'
+
+  const getTable = (name) => {
+    if (!store[name]) {
+      if (persist) {
+        try {
+          const saved = localStorage.getItem(prefix + name)
+          store[name] = saved ? JSON.parse(saved) : (initialData[name] || [])
+        } catch { store[name] = initialData[name] || [] }
+      } else {
+        store[name] = initialData[name] || []
+      }
+    }
+    return store[name]
+  }
+
+  const save = (name) => {
+    if (persist) {
+      try { localStorage.setItem(prefix + name, JSON.stringify(store[name])) } catch {}
+    }
+  }
+
+  const notify = (name, event, newItem, oldItem) => {
+    const fns = listeners[name]
+    if (!fns) return
+    for (const fn of fns) fn(newItem, oldItem, { event, table: name })
+  }
+
+  let idCounter = Date.now()
+
+  return {
+    name: 'local',
+    store,
+
+    select: async ({ from, params, ...modifiers }) => {
+      const table = getTable(from)
+      const filtered = table.filter(item => matchesParams(item, params))
+      return applyModifiers(filtered, modifiers)
+    },
+
+    insert: async ({ from, data }) => {
+      const table = getTable(from)
+      const items = Array.isArray(data) ? data : [data]
+      const inserted = items.map(item => {
+        const row = { id: item.id || ++idCounter, ...item }
+        table.push(row)
+        return row
+      })
+      save(from)
+      for (const row of inserted) notify(from, 'INSERT', row, null)
+      return { data: Array.isArray(data) ? inserted : inserted[0], error: null }
+    },
+
+    update: async ({ from, data, params }) => {
+      const table = getTable(from)
+      const updated = []
+      for (let i = 0; i < table.length; i++) {
+        if (matchesParams(table[i], params)) {
+          const old = { ...table[i] }
+          Object.assign(table[i], data)
+          updated.push(table[i])
+          notify(from, 'UPDATE', table[i], old)
+        }
+      }
+      save(from)
+      return { data: updated, error: null }
+    },
+
+    delete: async ({ from, params }) => {
+      const table = getTable(from)
+      const removed = []
+      for (let i = table.length - 1; i >= 0; i--) {
+        if (matchesParams(table[i], params)) {
+          removed.push(table[i])
+          table.splice(i, 1)
+          notify(from, 'DELETE', null, removed[removed.length - 1])
+        }
+      }
+      save(from)
+      return { data: removed, error: null }
+    },
+
+    subscribe: ({ from, on }, callback) => {
+      if (!listeners[from]) listeners[from] = []
+      const fn = (newItem, oldItem, payload) => {
+        if (on && on !== '*' && on !== payload.event) return
+        callback(newItem, oldItem, payload)
+      }
+      listeners[from].push(fn)
+      return () => {
+        const idx = listeners[from].indexOf(fn)
+        if (idx > -1) listeners[from].splice(idx, 1)
+      }
+    }
+  }
+}

package/adapters/rest.js

@@ -0,0 +1,147 @@
+'use strict'
+
+const buildUrl = (base, from, params) => {
+  const slash = from && !from.startsWith('/') ? '/' : ''
+  const url = new URL(`${base}${slash}${from}`)
+  if (params) {
+    for (const key in params) {
+      const val = params[key]
+      if (val !== undefined && val !== null) {
+        url.searchParams.set(key, typeof val === 'object' ? JSON.stringify(val) : val)
+      }
+    }
+  }
+  return url.toString()
+}
+
+const request = async (url, options) => {
+  const res = await globalThis.fetch(url, options)
+  const contentType = res.headers.get('content-type')
+  const data = contentType && contentType.includes('json')
+    ? await res.json()
+    : await res.text()
+  return { data, error: res.ok ? null : (data?.message || data?.error || res.statusText), status: res.status }
+}
+
+export const setup = async ({ url, headers, auth, fetchOptions }) => {
+  if (!url) throw new Error('@symbo.ls/fetch rest: url is required')
+  return restAdapter(url, headers, auth, fetchOptions)
+}
+
+export const restAdapter = (baseUrl, defaultHeaders = {}, authConfig, defaultFetchOptions = {}) => {
+  let token = authConfig?.token || null
+
+  const getHeaders = (extra) => {
+    const h = { ...defaultHeaders, ...extra }
+    if (token) h.Authorization = `Bearer ${token}`
+    return h
+  }
+
+  const getJsonHeaders = (extra) => ({ ...getHeaders(extra), 'Content-Type': 'application/json' })
+
+  const getFetchOptions = (opts) => ({ ...defaultFetchOptions, ...opts })
+
+  const resolveUrl = (from, base) => {
+    const b = base || baseUrl
+    if (from && (from.startsWith('http://') || from.startsWith('https://'))) return from
+    const slash = from && !from.startsWith('/') ? '/' : ''
+    return `${b}${slash}${from || ''}`
+  }
+
+  const adapter = {
+    name: 'rest',
+
+    // Auth
+    setToken: (t) => { token = t },
+
+    getSession: async () => {
+      if (!authConfig?.sessionUrl) {
+        return token ? { token } : null
+      }
+      const result = await request(
+        resolveUrl(authConfig.sessionUrl, authConfig.baseUrl),
+        getFetchOptions({ headers: getHeaders() })
+      )
+      return result.error ? null : result.data
+    },
+
+    signIn: async (credentials) => {
+      if (!authConfig?.signInUrl) throw new Error('rest: auth.signInUrl not configured')
+      const result = await request(resolveUrl(authConfig.signInUrl, authConfig.baseUrl), getFetchOptions({
+        method: 'POST',
+        headers: getJsonHeaders(),
+        body: JSON.stringify(credentials)
+      }))
+      if (result.data?.token) token = result.data.token
+      return result
+    },
+
+    signOut: async () => {
+      if (authConfig?.signOutUrl) {
+        await request(resolveUrl(authConfig.signOutUrl, authConfig.baseUrl), getFetchOptions({
+          method: 'POST',
+          headers: getHeaders()
+        }))
+      }
+      token = null
+      return { error: null }
+    },
+
+    // CRUD
+    select: ({ from, params, select, limit, offset, order, single, headers, baseUrl: fromBase }) => {
+      const allParams = { ...params }
+      if (select) allParams.select = select
+      if (limit) allParams.limit = limit
+      if (offset) allParams.offset = offset
+      if (single) allParams.single = true
+      if (order) {
+        if (typeof order === 'string') {
+          allParams.order = order
+        } else if (Array.isArray(order)) {
+          allParams.order = order.map(o => `${o.by}:${o.asc === false ? 'desc' : 'asc'}`).join(',')
+        } else if (order.by) {
+          allParams.order = `${order.by}:${order.asc === false ? 'desc' : 'asc'}`
+        }
+      }
+      return request(
+        buildUrl(fromBase || baseUrl, from || '', allParams),
+        getFetchOptions({ headers: getHeaders(headers) })
+      )
+    },
+
+    rpc: ({ from, params, headers, baseUrl: fromBase }) =>
+      request(resolveUrl(`rpc/${from}`, fromBase), getFetchOptions({
+        method: 'POST',
+        headers: getJsonHeaders(headers),
+        body: JSON.stringify(params)
+      })),
+
+    insert: ({ from, data, headers, baseUrl: fromBase }) =>
+      request(resolveUrl(from, fromBase), getFetchOptions({
+        method: 'POST',
+        headers: getJsonHeaders(headers),
+        body: JSON.stringify(data)
+      })),
+
+    update: ({ from, data, params, method, headers, baseUrl: fromBase }) => {
+      const id = params?.id || data?.id
+      const path = id ? `${from}/${id}` : from
+      return request(resolveUrl(path, fromBase), getFetchOptions({
+        method: method || 'PATCH',
+        headers: getJsonHeaders(headers),
+        body: JSON.stringify(data)
+      }))
+    },
+
+    delete: ({ from, params, headers, baseUrl: fromBase }) => {
+      const id = params?.id
+      const path = id ? `${from}/${id}` : from
+      return request(resolveUrl(path, fromBase), getFetchOptions({
+        method: 'DELETE',
+        headers: getHeaders(headers)
+      }))
+    }
+  }
+
+  return adapter
+}

package/adapters/supabase.js

@@ -0,0 +1,153 @@
+'use strict'
+
+export const setup = async ({ url, key, projectId, createClient, ...options }) => {
+  const supabaseUrl = url || (projectId && `https://${projectId}.supabase.co`)
+  if (!supabaseUrl || !key) {
+    throw new Error('@symbo.ls/fetch supabase: url (or projectId) and key are required')
+  }
+  if (!createClient) {
+    const pkg = '@supabase/' + 'supabase-js'
+    const mod = await import(/* webpackIgnore: true */ pkg)
+    createClient = mod.createClient
+  }
+  return supabaseAdapter(createClient(supabaseUrl, key, options))
+}
+
+const applyFilters = (query, params) => {
+  if (!params) return query
+  for (const key in params) {
+    const val = params[key]
+    if (val === null) {
+      query = query.is(key, null)
+    } else if (Array.isArray(val)) {
+      query = query.in(key, val)
+    } else if (typeof val === 'object') {
+      for (const op in val) {
+        if (op === 'gt') query = query.gt(key, val[op])
+        else if (op === 'gte') query = query.gte(key, val[op])
+        else if (op === 'lt') query = query.lt(key, val[op])
+        else if (op === 'lte') query = query.lte(key, val[op])
+        else if (op === 'neq') query = query.neq(key, val[op])
+        else if (op === 'like') query = query.like(key, val[op])
+        else if (op === 'ilike') query = query.ilike(key, val[op])
+        else if (op === 'in') query = query.in(key, val[op])
+        else if (op === 'is') query = query.is(key, val[op])
+        else if (op === 'contains') query = query.contains(key, val[op])
+        else if (op === 'containedBy') query = query.containedBy(key, val[op])
+        else if (op === 'textSearch') query = query.textSearch(key, val[op])
+      }
+    } else {
+      query = query.eq(key, val)
+    }
+  }
+  return query
+}
+
+const applyModifiers = (query, { limit, offset, order, single } = {}) => {
+  if (order) {
+    if (Array.isArray(order)) {
+      for (const o of order) {
+        const by = typeof o === 'string' ? o : o.by
+        query = query.order(by, { ascending: o.asc !== false })
+      }
+    } else {
+      const orderBy = typeof order === 'string' ? order : order.by
+      query = query.order(orderBy, { ascending: order.asc !== false })
+    }
+  }
+  if (limit) query = query.limit(limit)
+  if (offset) query = query.range(offset, offset + (limit || 20) - 1)
+  if (single) query = query.single()
+  return query
+}
+
+export const supabaseAdapter = (client) => ({
+  name: 'supabase',
+  client,
+
+  // Auth
+  getSession: async () => {
+    const { data } = await client.auth.getSession()
+    return data?.session || null
+  },
+
+  getUser: async () => {
+    const { data } = await client.auth.getUser()
+    return data?.user || null
+  },
+
+  signIn: (credentials) => {
+    if (credentials.provider) {
+      return client.auth.signInWithOAuth({ provider: credentials.provider })
+    }
+    if (credentials.token) {
+      return client.auth.signInWithIdToken(credentials)
+    }
+    return client.auth.signInWithPassword(credentials)
+  },
+
+  signUp: (credentials) => client.auth.signUp(credentials),
+
+  signOut: () => client.auth.signOut(),
+
+  onAuthStateChange: (callback) => {
+    const { data: { subscription } } = client.auth.onAuthStateChange(
+      (event, session) => callback(event, session)
+    )
+    return () => subscription.unsubscribe()
+  },
+
+  // CRUD
+  select: async ({ from, select, params, ...modifiers }) => {
+    let q = client.from(from).select(select || '*')
+    q = applyFilters(q, params)
+    q = applyModifiers(q, modifiers)
+    return q
+  },
+
+  rpc: ({ from, params }) => client.rpc(from, params),
+
+  insert: ({ from, data, select }) =>
+    client.from(from).insert(data).select(select || '*'),
+
+  update: ({ from, data, params, select }) => {
+    let q = client.from(from).update(data)
+    q = applyFilters(q, params)
+    return q.select(select || '*')
+  },
+
+  upsert: ({ from, data, select }) =>
+    client.from(from).upsert(data).select(select || '*'),
+
+  delete: ({ from, params }) => {
+    let q = client.from(from).delete()
+    q = applyFilters(q, params)
+    return q
+  },
+
+  // Realtime
+  subscribe: ({ from, params, on }, callback) => {
+    const event = on || '*'
+    const channel = client
+      .channel(`db-${from}-${Date.now()}`)
+      .on('postgres_changes', {
+        event,
+        schema: 'public',
+        table: from,
+        ...(params?.id ? { filter: `id=eq.${params.id}` } : {})
+      }, (payload) => callback(payload.new, payload.old, payload))
+      .subscribe()
+
+    return () => client.removeChannel(channel)
+  },
+
+  // Storage
+  upload: ({ bucket, path, file, options }) =>
+    client.storage.from(bucket).upload(path, file, options),
+
+  download: ({ bucket, path }) =>
+    client.storage.from(bucket).download(path),
+
+  getPublicUrl: ({ bucket, path }) =>
+    client.storage.from(bucket).getPublicUrl(path)
+})