OrbitDB Factory

/**
 * Creates an OrbitDB instance
 * @param params Configuration parameters
 * @param params.ipfs IPFS instance (required)
 * @param params.id Identity ID (optional, auto-generated if not provided)
 * @param params.identity Identity instance or provider configuration
 * @param params.identities Identities system instance
 * @param params.directory Storage directory (default: './orbitdb')
 * @returns Promise resolving to OrbitDB instance
 * @throws "IPFS instance is a required argument" if no IPFS instance provided
 */
function createOrbitDB(params: {
  ipfs: IPFS;
  id?: string;
  identity?: Identity | { provider: IdentityProvider };
  identities?: Identities;
  directory?: string;
}): Promise<OrbitDB>;

import { createHelia } from 'helia';
import { createOrbitDB } from '@orbitdb/core';

// Basic usage with Helia IPFS
const ipfs = await createHelia();
const orbitdb = await createOrbitDB({ ipfs });

// With custom directory
const orbitdb2 = await createOrbitDB({ 
  ipfs, 
  directory: './my-orbitdb-data' 
});

// With custom identity ID
const orbitdb3 = await createOrbitDB({ 
  ipfs, 
  id: 'my-unique-id' 
});

interface OrbitDB {
  /** Opens or creates a database */
  open(name: string, options?: DatabaseOptions): Promise<Database>;
  /** Stops the OrbitDB instance and cleans up resources */
  stop(): Promise<void>;
  /** The IPFS instance used by this OrbitDB */
  ipfs: IPFS;
  /** The directory where OrbitDB stores data */
  directory: string;
  /** The keystore instance for cryptographic operations */
  keystore: KeyStore;
  /** The identities system for identity management */
  identities: Identities;
  /** The current identity used by this OrbitDB instance */
  identity: Identity;
  /** The peer ID of this OrbitDB instance */
  peerId: PeerId;
}

/**
 * Opens or creates a database
 * @param name Database name or address
 * @param options Database configuration options
 * @returns Promise resolving to Database instance
 */
open(name: string, options?: DatabaseOptions): Promise<Database>;

interface DatabaseOptions {
  /** Database type (default: 'events') */
  type?: string;
  /** Database constructor function */
  Database?: DatabaseConstructor;
  /** Access controller constructor */
  AccessController?: AccessControllerConstructor;
  /** Storage directory for this database */
  directory?: string;
  /** Database metadata */
  meta?: object;
  /** Storage backend for log heads */
  headsStorage?: Storage;
  /** Storage backend for log entries */
  entryStorage?: Storage;
  /** Storage backend for database index */
  indexStorage?: Storage;
  /** Maximum distance between references (default: 16) */
  referencesCount?: number;
  /** Enable automatic peer synchronization (alias: sync) */
  syncAutomatically?: boolean;
  /** Callback fired when entries are added */
  onUpdate?: (entry: Entry) => void;
  /** Encryption configuration */
  encryption?: {
    encryptFn: (data: any) => any;
    decryptFn: (data: any) => any;
  };
}

import { createHelia } from 'helia';
import { createOrbitDB, Documents, KeyValue } from '@orbitdb/core';

const ipfs = await createHelia();
const orbitdb = await createOrbitDB({ ipfs });

// Open default Events database
const events = await orbitdb.open('my-events');

// Open Documents database with custom index
const docs = await orbitdb.open('my-docs', {
  Database: Documents({ indexBy: 'id' })
});

// Open KeyValue database with custom metadata
const kv = await orbitdb.open('my-kv', {
  Database: KeyValue(),
  meta: { description: 'My key-value store' }
});

// Open database with custom access control
const privateDb = await orbitdb.open('private-db', {
  AccessController: OrbitDBAccessController({ write: ['alice', 'bob'] })
});

// Open database with automatic sync
const syncedDb = await orbitdb.open('synced-db', {
  syncAutomatically: true,
  onUpdate: (entry) => console.log('New entry:', entry)
});

// Open by name (creates new database or opens existing)
const db1 = await orbitdb.open('my-database');

// Open by full OrbitDB address
const address = '/orbitdb/zdpuAkstgbTVGHQmMi5TC84auhJ8rL5qoaNEtXo2d5PHXs2To';
const db2 = await orbitdb.open(address);

// Get database address for sharing
const dbAddress = db1.address.toString();
console.log('Share this address:', dbAddress);

import { createOrbitDB, Identities, PublicKeyIdentityProvider } from '@orbitdb/core';

// Using default identity (auto-generated)
const orbitdb1 = await createOrbitDB({ ipfs });

// Using custom identity provider
const identities = await Identities({ ipfs });
const identity = await identities.createIdentity({ 
  provider: PublicKeyIdentityProvider() 
});

const orbitdb2 = await createOrbitDB({ 
  ipfs, 
  identity 
});

// Using pre-created identities instance
const orbitdb3 = await createOrbitDB({ 
  ipfs, 
  identities 
});

import { 
  createOrbitDB, 
  LevelStorage, 
  MemoryStorage, 
  ComposedStorage 
} from '@orbitdb/core';

const ipfs = await createHelia();
const orbitdb = await createOrbitDB({ ipfs });

// Configure storage for specific database
const db = await orbitdb.open('my-db', {
  headsStorage: await LevelStorage({ path: './heads' }),
  entryStorage: await MemoryStorage(),
  indexStorage: await ComposedStorage([
    await MemoryStorage(),
    await LevelStorage({ path: './index' })
  ])
});

const ipfs = await createHelia();
const orbitdb = await createOrbitDB({ ipfs });

try {
  // Use OrbitDB
  const db = await orbitdb.open('my-db');
  await db.add('Hello World');
  await db.close();
} finally {
  // Always clean up
  await orbitdb.stop();
  await ipfs.stop();
}

import { createOrbitDB } from '@orbitdb/core';

try {
  // Missing IPFS instance
  const orbitdb = await createOrbitDB({});
} catch (error) {
  console.error(error.message); // "IPFS instance is a required argument."
}

try {
  const ipfs = await createHelia();
  const orbitdb = await createOrbitDB({ ipfs });
  
  // Invalid database address
  const db = await orbitdb.open('invalid-address');
} catch (error) {
  console.error('Failed to open database:', error.message);
}

import { createHelia } from 'helia';
import { createLibp2p } from 'libp2p';
import { gossipsub } from '@chainsafe/libp2p-gossipsub';
import { identify } from '@libp2p/identify';
import { createOrbitDB } from '@orbitdb/core';

// Configure Libp2p for OrbitDB
const libp2pOptions = {
  services: {
    pubsub: gossipsub({
      allowPublishToZeroTopicPeers: true
    }),
    identify: identify()
  }
};

const libp2p = await createLibp2p(libp2pOptions);
const ipfs = await createHelia({ libp2p });
const orbitdb = await createOrbitDB({ ipfs });

// Now OrbitDB can sync with peers
const db = await orbitdb.open('shared-db');