HyperStack Client

npm install @hyperstack/core

import { HyperStack } from '@hyperstack/core';

const stack = {
  name: 'my-stack',
  url: 'wss://api.example.com',
  views: {
    users: {
      state: { mode: 'state' as const, view: 'users.state' },
      list: { mode: 'list' as const, view: 'users.list' },
    },
  },
};

const client = await HyperStack.connect(stack);

static async connect<T extends StackDefinition>(
  stack: T,
  options?: ConnectOptions
): Promise<HyperStack<T>>

get views: TypedViews<TStack['views']>

const user = await client.views.users.state.get('user-123');
const allUsers = await client.views.users.list.get();

get instructions: InstructionsInterface<TStack['instructions']>

const result = await client.instructions.createUser(
  { name: 'Alice' },
  { wallet }
);

get connectionState: ConnectionState

const state = client.connectionState;
if (state === 'connected') {
  console.log('Ready to subscribe');
}

get stackName: string

get store: StorageAdapter

async connect(): Promise<void>

const client = await HyperStack.connect(stack, { autoReconnect: false });
await client.connect(); // Manually connect

disconnect(): void

client.disconnect();

isConnected(): boolean

if (client.isConnected()) {
  // Perform operations
}

clearStore(): void

client.clearStore();

onConnectionStateChange(
  callback: ConnectionStateCallback
): UnsubscribeFn

const unsubscribe = client.onConnectionStateChange((state, error) => {
  console.log('Connection state:', state);
  if (error) {
    console.error('Connection error:', error);
  }
});

// Stop listening
unsubscribe();

onFrame(callback: (frame: Frame) => void): UnsubscribeFn

const unsubscribe = client.onFrame((frame) => {
  console.log('Received frame:', frame);
});

import { HyperStack } from '@hyperstack/core';
import { IndexedDBAdapter } from '@hyperstack/storage-indexeddb';

const storage = new IndexedDBAdapter({ dbName: 'my-app' });

const client = await HyperStack.connect(stack, {
  storage,
});

import { z } from 'zod';

const UserSchema = z.object({
  id: z.string(),
  name: z.string(),
  email: z.string().email(),
});

const stack = {
  name: 'my-stack',
  url: 'wss://api.example.com',
  views: { /* ... */ },
  schemas: {
    'users.state': UserSchema,
  },
};

const client = await HyperStack.connect(stack, {
  validateFrames: true,
});

const client = await HyperStack.connect(stack, {
  maxEntriesPerView: 1000, // Keep max 1000 entities per view
});

import type {
  HyperStackOptions,
  HyperStackOptionsWithStorage,
  ConnectOptions,
  StackDefinition,
  ConnectionState,
  ConnectionStateCallback,
  UnsubscribeFn,
} from '@hyperstack/core';

import { HyperStackError } from '@hyperstack/core';

try {
  const client = await HyperStack.connect(stack);
} catch (error) {
  if (error instanceof HyperStackError) {
    console.error(`${error.code}: ${error.message}`);
    console.error('Details:', error.details);
  }
}