@enbox/api

bun add @enbox/api

import { Enbox } from '@enbox/api';

const enbox = Enbox.connect({ agent, connectedDid: did });

const enbox = Enbox.connect({ session });

import { defineProtocol } from '@enbox/api';

interface TaskData {
  title: string;
  done: boolean;
}

const TaskProtocol = defineProtocol({
  protocol:  'https://example.com/tasks',
  published: true,
  types: {
    task: {
      schema:      'https://example.com/schemas/task',
      dataFormats: ['application/json'],
    },
  },
  structure: {
    task: {},
  },
}, {} as {
  task: TaskData;
});

const tasks = enbox.using(TaskProtocol);

const { status } = await tasks.configure();
// status.code: 200 (already installed) or 202 (newly installed)

const { status, record } = await tasks.records.create('task', {
  data: { title: 'Buy milk', done: false },
});
// record is TypedRecord<TaskData>

const { records, cursor } = await tasks.records.query('task');

for (const r of records) {
  const data = await r.data.json(); // TaskData
  console.log(data.title, data.done);
}

import { DateSort } from '@enbox/dwn-sdk-js';

const { records, cursor } = await tasks.records.query('task', {
  filter: { tags: { done: false } },
  dateSort: DateSort.CreatedDescending,
  pagination: { limit: 25 },
});

// Fetch next page
if (cursor) {
  const { records: next } = await tasks.records.query('task', {
    pagination: { limit: 25, cursor },
  });
}

const { record } = await tasks.records.read('task', {
  filter: { recordId: taskId },
});

const data = await record.data.json(); // TaskData

const { record } = await tasks.records.read('task', {
  from: 'did:dht:alice...',
  filter: { recordId: taskId },
});

const { status } = await tasks.records.delete('task', {
  recordId: record.id,
});

await record.delete();

const { liveQuery } = await tasks.records.subscribe('task');

const task = await record.data.json();    // Promise<TaskData>
const raw  = await record.data.text();    // Promise<string>
const blob = await record.data.blob();    // Promise<Blob>
const bytes = await record.data.bytes();  // Promise<Uint8Array>
const stream = await record.data.stream(); // Promise<ReadableStream>

const { status, record: updated } = await record.update({
  data: { title: 'Buy oat milk', done: false },  // Partial<TaskData>
  tags: { priority: 'high' },
});

const { status } = await record.delete();
// status.code: 202 on success

await record.delete({ prune: true });  // also delete child records

const { liveQuery } = await tasks.records.subscribe('task');

// Initial snapshot
for (const record of liveQuery.records) {
  console.log(await record.data.json());
}

// Real-time events
liveQuery.on('create', (record) => {
  console.log('New task:', record.id);
});

liveQuery.on('update', (record) => {
  console.log('Updated:', record.id);
});

liveQuery.on('delete', (record) => {
  console.log('Deleted:', record.id);
});

// Catch-all
liveQuery.on('change', (change) => {
  console.log(change.type, change.record.id);
});

const off = liveQuery.on('create', handler);
off(); // stop listening

await liveQuery.close();

liveQuery.on('disconnected', () => showOfflineBanner());
liveQuery.on('reconnecting', ({ attempt }) => {
  console.log(`Reconnection attempt ${attempt}...`);
});
liveQuery.on('reconnected', () => hideOfflineBanner());

const { dwn } = Enbox.anonymous();

const { records } = await dwn.records.query({
  from: 'did:dht:alice...',
  filter: {
    protocol: 'https://social.example/posts',
    protocolPath: 'post',
  },
});

for (const record of records) {
  console.log(record.id, await record.data.text());
}

const NotebookProtocol = defineProtocol({
  protocol:  'https://example.com/notebooks',
  published: true,
  types: {
    notebook: {
      schema:      'https://example.com/schemas/notebook',
      dataFormats: ['application/json'],
    },
    page: {
      schema:      'https://example.com/schemas/page',
      dataFormats: ['application/json'],
    },
  },
  structure: {
    notebook: {
      page: {},
    },
  },
}, {} as {
  notebook: { name: string };
  page: { title: string; body: string };
});

const notebooks = enbox.using(NotebookProtocol);

// Create a parent
const { record: notebook } = await notebooks.records.create('notebook', {
  data: { name: 'Travel Notes' },
});

// Create a child under the parent
const { record: page } = await notebooks.records.create('notebook/page', {
  data: { title: 'Day 1', body: 'Arrived in Tokyo...' },
  parentContextId: notebook.contextId,
});

// Query children of a specific parent
const { records: pages } = await notebooks.records.query('notebook/page', {
  filter: { parentId: notebook.contextId },
});

await enbox.disconnect();