Community library

client.community reads the community library, the shared collection of characters, locations and objects curated by the Nodaro team. You can browse and search it, read a listing, clone a listing into your own account, favorite it, and report it for moderation. The methods call the Community REST API. See Community library for the feature and its likeness and consent rules.

The community library exists on multi-user installs: Nodaro Cloud and Business edition. A single-user Community edition install answers every call with NotFoundError. A deployment that does not allow public work serves no listing: browse() and favorites() return empty lists, and get(), getFull() and clone() throw NotFoundError.

Methods

Publishing is not part of the SDK: the SDK's personal and OAuth tokens cannot publish.

client.community

A listing is a CommunityCard. Its fields use snake_case, as the API sends them. CommunityEntityType is "character", "location" or "object".

browse(params?)

Returns a page of public listings and a nextCursor (GET /v1/community/browse). Pass nextCursor back as cursor for the next page; it is null on the last page.

browse(params?: BrowseCommunityParams): Promise<{ data: CommunityCard[]; nextCursor: string | null }>

const { data: listings, nextCursor } = await client.community.browse({
  entityType: "character",
  sort: "popular",
  limit: 20,
})

get(slug)

Reads one listing by its slug (GET /v1/community/detail/:slug).

get(slug: string): Promise<{ data: CommunityCard }>

const { data: listing } = await client.community.get("detective-mara")

Throws NotFoundError when the listing does not exist or is no longer active.

getFull(slug)

Reads one listing with its full public snapshot: its images, voice and text, as a detail page shows them (GET /v1/community/detail/:slug/full).

getFull(slug: string): Promise<{ data: CommunityFullDetail }>

const { data: detail } = await client.community.getFull("detective-mara")

favorites()

Lists the listings you favorited (GET /v1/community/favorites).

favorites(): Promise<{ data: CommunityCard[] }>

const { data: favorites } = await client.community.favorites()

clone(id, entityType)

Copies a listing into your library as an independent copy (POST /v1/community/listings/:id/clone). Its files are copied into your own storage, so the copy stays when the original changes or is removed. It returns the kind and id of your new asset.

clone(id: string, entityType: "character" | "location" | "object"): Promise<{ entityType: string; id: string }>

const { id: characterId } = await client.community.clone(listingId, "character")
const character = await client.characters.get(characterId)

An OAuth token needs the assets:write scope. Throws StorageExceededError when your storage is full.

favorite(id)

Adds a listing to your favorites, or removes it when it is already there (POST /v1/community/listings/:id/favorite). It returns the new state.

favorite(id: string): Promise<{ favorited: boolean }>

const { favorited } = await client.community.favorite(listingId)

report(id, reason)

Reports a listing for moderation (POST /v1/community/listings/:id/report).

report(id: string, reason: CommunityReportReason): Promise<{ ok: true }>

await client.community.report(listingId, "real_person_no_consent")

client.keepers

client.keepers reads Nodaro Keepers, the shared shelf of characters, creatures, locations and objects that the platform's admins choose, and copies an item into your account. The methods call the Keepers routes. Reading the shelf needs no credential, so a guest can browse it. Reading and copying cost no credits.

catalog(params?)

Returns one page of the shelf: { data: KeeperCatalogItem[], next }.

catalog(params?: { kind?: KeeperKind; cursor?: string; limit?: number }): Promise<KeeperCatalogPage>

Each item is { id, kind, name, description, imageUrl, previewUrl, category, sort, createdAt }. previewUrl is a 480-pixel-wide copy of the main image, for a tile. category is the shelf heading and sort the shelf order. The shelf holds display fields only. It is cached for a minute, and one address can read it 60 times a minute.

const { data, next } = await client.keepers.catalog({ kind: "character" })

copy(kind, id)

Copies a shelf item into your account and returns { id, name, kind, created }. id is your own row: read it with client.characters.get(id) and the other asset methods.

copy(kind: KeeperKind, id: string): Promise<CopyKeeperResult>

• The copy holds the public text, the main image and the variant assets. Every file is copied into your own storage and counts against it.
• A premade or library voice is carried. A custom or cloned voice is reduced to its name and sample. The owner's picker selections, reference photos and trained-model fields are never carried.
• The copy goes into your default project. It does not change when the original changes.
• One copy per person and item: a later call returns the same copy with created: false. A copy you archived comes back unarchived, and a copy you already have stays yours whether or not the item is still on the shelf.
• Throws NotFoundError for an item that is not on the shelf when you have no copy of it, a 413 storage_limit_exceeded when its files do not fit your storage, and ForbiddenError with personal_space_disabled when your organization closed the personal space.
• An OAuth app token needs the assets:write scope.

const { id } = await client.keepers.copy("character", item.id)
const mine = await client.characters.get(id)