JavaScript client

npm install @baselyra/client

import { createClient } from '@baselyra/client';

export const bl = createClient(
  import.meta.env.VITE_BASELYRA_URL,
  import.meta.env.VITE_BASELYRA_ANON_KEY,
);

createClient(url, anonKey, {
  auth: {
    persistSession: true,             // default
    autoRefreshToken: true,           // default
    storageKey: 'baselyra.auth.session',
    storage: myStorageAdapter,        // getItem / setItem / removeItem, synchronous
  },
  global: {
    headers: { 'x-client-info': 'acme-web/1.4.0' },
    fetch: myFetch,                   // a Node agent, a test double, a retrying wrapper
  },
  realtime: {
    enabled: true,                    // false never opens the socket
    heartbeatIntervalMs: 25_000,
    maxReconnectDelayMs: 30_000,
    WebSocket: MyWebSocket,
  },
});

const { data, error, count, status } = await bl.from('posts').select('*');
if (error) {
  if (error.isNetworkError) return showOffline();   // status === 0
  return showMessage(error.message);                // error.code, error.status, error.details
}
render(data);

const { data, error, count } = await bl
  .from('posts')
  .select('id,title,tags,author:users(id,name)', { count: 'exact' })
  .eq('published', true)
  .neq('kind', 'draft')
  .gt('score', 10).gte('score', 10).lt('score', 99).lte('score', 99)
  .like('title', '*sql*').ilike('title', '*SQL*')     // * is the wildcard
  .is('deleted_at', null)                             // the only correct null test
  .in('id', [1, 2, 3])
  .contains('tags', ['sql'])                          // @>
  .containedBy('tags', ['sql', 'db'])                 // <@
  .overlaps('tags', ['sql', 'db'])                    // &&
  .match({ status: 'open', kind: 'bug' })             // eq on every key
  .not('state', 'eq', 'archived')
  .or('status.eq.draft,and(views.gte.100,pinned.is.true)')
  .textSearch('search', 'postgres -mysql', { type: 'websearch', config: 'english' })
  .order('created_at', { ascending: false, nullsFirst: false })
  .range(0, 19);                                      // or .limit(20)

await bl.from('posts').insert({ title: 'Hello' }).select().single();
await bl.from('posts').upsert(rows, { onConflict: 'slug' });
await bl.from('posts').update({ title: 'x' }).eq('id', 1);
await bl.from('posts').delete().eq('id', 1);
await bl.from('posts').delete().unsafeMutation();      // every row. Deliberate.
await bl.rpc('search_posts', { term: 'sql' });

import type { Database } from './database.types';

const bl = createClient<Database>(url, ANON_KEY);
const { data } = await bl.from('posts').select('*');   // data: Post[] | null

await bl.auth.signUp({ email, password, data: { name: 'Ada' } });
await bl.auth.signInWithPassword({ email, password });
await bl.auth.signInWithOtp({ email, type: 'magiclink' });      // or type: 'otp'
await bl.auth.verifyOtp({ email, token: '123456', type: 'otp' });
await bl.auth.resetPasswordForEmail(email);
await bl.auth.resend({ type: 'confirmation', email });
await bl.auth.updateUser({ password: 'a-new-one', data: { theme: 'dark' } });
await bl.auth.refreshSession();
await bl.auth.signOut({ scope: 'global' });

const { data: { session } } = await bl.auth.getSession();   // refreshes first if expired
const { data: { user } } = await bl.auth.getUser();         // asks the server
bl.auth.accessToken;                                        // the raw token, no round trip
bl.auth.setSession(session);                                // adopt one from elsewhere
bl.auth.stopAutoRefresh();                                  // let a Node process exit

const { data: { subscription } } = bl.auth.onAuthStateChange((event, session) => {
  setUser(session?.user ?? null);
});
// SIGNED_IN | SIGNED_OUT | TOKEN_REFRESHED | USER_UPDATED
return () => subscription.unsubscribe();

const bucket = bl.storage.from('avatars');

await bucket.upload('me.png', file, { upsert: true, contentType: 'image/png' });
await bucket.update('me.png', file);                       // always overwrites
await bucket.list('teams/', { limit: 100, sortBy: { column: 'name', order: 'asc' } });
await bucket.move('me.png', 'archive/me.png');
await bucket.copy('me.png', 'archive/me.png');
await bucket.remove(['me.png', 'old.png']);

const { data: blob } = await bucket.download('me.png');    // data is a Blob
const { data: signed } = await bucket.createSignedUrl('me.png', 3600);
bucket.getPublicUrl('me.png');                             // no request; public buckets only

await bl.storage.listBuckets();
await bl.storage.getBucket('avatars');
await bl.storage.createBucket('invoices', { public: false });   // service key
await bl.storage.updateBucket('invoices', { file_size_limit: 10485760 });
await bl.storage.deleteBucket('invoices');                      // refused while not empty

const channel = bl.channel('room:' + roomId);

channel
  .on('postgres_changes',
      { event: 'INSERT', schema: 'public', table: 'messages', filter: 'room_id=eq.' + roomId },
      ({ new: row }) => append(row))
  .on('broadcast', { event: 'typing' }, ({ payload }) => showTyping(payload))
  .on('presence', { event: 'sync' }, ({ state }) => setHere(Object.values(state)));

const status = await channel.subscribe();      // SUBSCRIBED | CHANNEL_ERROR | TIMED_OUT | CLOSED
await channel.track({ name: 'Ada' });
await channel.send({ type: 'broadcast', event: 'typing', payload: { name: 'Ada' } });
channel.presence();                            // everyone here, keyed by connection id

bl.getChannels();
await bl.removeChannel(channel);
await bl.removeAllChannels();

const off = bl.realtime.onError((message) => console.warn('realtime:', message));

import { useEffect, useState } from 'react';
import { bl } from './lib/baselyra';

type Message = { id: number; body: string; author: string };

export function Chat({ roomId, name }: { roomId: number; name: string }) {
  const [messages, setMessages] = useState<Message[]>([]);
  const [typing, setTyping] = useState<string[]>([]);
  const [here, setHere] = useState<string[]>([]);
  const [draft, setDraft] = useState('');
  const topic = 'room:' + roomId;

  useEffect(() => {
    // Created inside the effect: the cleanup drops it, so a remount binds a
    // fresh channel instead of stacking a second set of callbacks on the old one.
    const channel = bl.channel(topic);

    bl.from('messages').select('id,body,author')
      .eq('room_id', roomId).order('created_at').limit(50)
      .then(({ data }) => setMessages(data ?? []));

    channel
      .on<Message>('postgres_changes',
        { event: 'INSERT', schema: 'public', table: 'messages', filter: 'room_id=eq.' + roomId },
        ({ new: row }) => setMessages((prev) => (row ? [...prev, row] : prev)))
      .on('broadcast', { event: 'typing' }, ({ payload }) => {
        const who = (payload as { name: string }).name;
        setTyping((prev) => [...new Set([...prev, who])]);
        setTimeout(() => setTyping((prev) => prev.filter((n) => n !== who)), 2000);
      })
      .on('presence', { event: 'sync' }, ({ state }) =>
        setHere(Object.values(state).map((m) => (m as { name: string }).name)));

    channel.subscribe().then((status) => {
      if (status === 'SUBSCRIBED') void channel.track({ name });
    });

    return () => { void bl.removeChannel(channel); };
  }, [topic, name]);

  async function send(event: React.FormEvent) {
    event.preventDefault();
    const body = draft.trim();
    if (!body) return;
    setDraft('');
    // The INSERT comes back over the channel above, so nothing is appended here.
    const { error } = await bl.from('messages').insert({ room_id: roomId, body, author: name });
    if (error) alert(error.message);
  }

  return (
    <form onSubmit={send}>
      <p>{here.length} here{typing.length > 0 && ' · ' + typing.join(', ') + ' typing…'}</p>
      <ul>{messages.map((m) => <li key={m.id}><b>{m.author}</b> {m.body}</li>)}</ul>
      <input value={draft} placeholder="Message" onChange={(e) => {
        setDraft(e.target.value);
        void bl.channel(topic).send({ type: 'broadcast', event: 'typing', payload: { name } });
      }} />
    </form>
  );
}

const { data, error } = await bl.ai.chat(
  [{ role: 'user', content: 'Summarise this order.' }],
  { system: 'You are a support assistant for Acme.', signal: controller.signal },
);
console.log(data?.content);

const { data: status } = await bl.ai.status();   // { enabled, model }

import { createClient } from '@baselyra/client';

const bl = createClient(process.env.BASELYRA_URL, process.env.BASELYRA_SERVICE_KEY, {
  auth: { persistSession: false, autoRefreshToken: false },
  realtime: { enabled: false },
});

const { data } = await bl.from('profiles').select('id,email').eq('plan', 'free');

await bl.dispose();   // release the refresh timer and the socket, or the process hangs