@misofm/partyos 0.1.0 → 0.3.0

package/src/queries.ts

@@ -2,11 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Typed reads: fetch an on-chain object (or dynamic field) via the Core API, BCS-parse
-// it through the generated struct, and map to the public camelCase types.
+// it through the generated struct, and map to the public camelCase types. Every read
+// requires the `SuiClient` service (see `@misofm/effect`) instead of taking a client
+// parameter; not-found and type-mismatch paths are typed failures, not thrown errors.
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
+import { Effect, Option, Stream } from "effect";
 import { deriveDynamicFieldID, deriveObjectID, normalizeStructTag } from "@mysten/sui/utils";
 import { bcs } from "@mysten/sui/bcs";
+import {
+  assertObjectType,
+  decodeBcs,
+  getObjectContent,
+  getObjectsContent,
+  getOptionalObjectContent,
+  listDynamicFields,
+  type SuiClient,
+} from "@misofm/effect";
+import type { BcsDecodeError, ObjectNotFoundError, ObjectTypeMismatchError, SuiRpcError } from "@misofm/effect";
 import {
   MembershipKey as MembershipKeyBcs,
   Party as PartyBcs,
@@ -14,87 +26,63 @@ import {
   PendingMembershipKey as PendingMembershipKeyBcs,
 } from "./contracts/partyos/party.ts";
 import { keyBytes, mapParty } from "./internal.ts";
-import type { Party } from "./types.ts";
-
-/** True for the Core API's "object does not exist" error (a missing dynamic field). */
-export function isNotFound(e: unknown): boolean {
-  const msg = e instanceof Error ? e.message : String(e);
-  return /not\s*found|does not exist|no object/i.test(msg);
-}
-
-/**
- * Reads an object's BCS content, or null when it does not exist. A missing
- * object (e.g. an unset dynamic field) surfaces as a thrown "not found" from the
- * Core API, not an empty result, so optional reads can treat it as absence.
- */
-export async function getObjectContent(client: ClientWithCoreApi, objectId: string): Promise<Uint8Array | null> {
-  try {
-    const { object } = await client.core.getObject({ objectId, include: { content: true } });
-    return object?.content ?? null;
-  } catch (e) {
-    if (isNotFound(e)) return null;
-    throw e;
-  }
-}
+import { Party } from "./types.ts";
 
 /** The `Party` struct tag of one partyos deployment. */
 export function partyType(partyPackageId: string): string {
   return normalizeStructTag(`${partyPackageId}::party::Party`);
 }
 
-// A Party from another partyos package (a previous generation) parses
-// identically but no deployed package accepts it, so the object's type is
-// checked against the deployment before its content is trusted.
-function assertPartyType(objectId: string, type: string | undefined, partyPackageId: string): void {
-  const expected = partyType(partyPackageId);
-  if (type === undefined || normalizeStructTag(type) !== expected) {
-    throw new Error(
-      `Object ${objectId} is ${type ?? "of unknown type"}, not a ${expected}` +
-        (type?.endsWith("::party::Party") ? " (a Party from a different partyos deployment)" : ""),
-    );
-  }
+/** Decodes one object's BCS content into a `Party`, mapping the generated parse output first. */
+function decodeParty(objectId: string, content: Uint8Array, expectedType: string) {
+  return decodeBcs(
+    { parse: (bytes) => mapParty(objectId, PartyBcs.parse(bytes)) },
+    Party,
+    content,
+    { type: expectedType, objectId },
+  );
 }
 
 /** Fetches and parses a shared `Party` object of this deployment's partyos package. */
-export async function getPartyById(
-  client: ClientWithCoreApi,
+export const getPartyById = Effect.fn("getPartyById")(function* (
   partyId: string,
   partyPackageId: string,
-): Promise<Party> {
-  let object;
-  try {
-    ({ object } = await client.core.getObject({ objectId: partyId, include: { content: true } }));
-  } catch (e) {
-    if (isNotFound(e)) throw new Error(`Party not found: ${partyId}`);
-    throw e;
-  }
-  if (!object?.content) throw new Error(`Party not found: ${partyId}`);
-  assertPartyType(partyId, object.type, partyPackageId);
-  return mapParty(partyId, PartyBcs.parse(object.content));
-}
+): Effect.fn.Return<
+  Party,
+  ObjectNotFoundError | ObjectTypeMismatchError | BcsDecodeError | SuiRpcError,
+  SuiClient
+> {
+  const expected = partyType(partyPackageId);
+  const object = yield* getObjectContent(partyId);
+  // A Party from another partyos package (a previous generation) parses
+  // identically but no deployed package accepts it, so the object's type is
+  // checked against the deployment before its content is trusted.
+  yield* assertObjectType(partyId, normalizeStructTag(object.type), expected);
+  return yield* decodeParty(partyId, object.content, expected);
+});
 
 /**
  * Fetches and parses multiple shared `Party` objects in one Core request.
  * Missing objects are skipped; an object of another type is an error.
  */
-export async function getPartiesByIds(
-  client: ClientWithCoreApi,
+export const getPartiesByIds = Effect.fn("getPartiesByIds")(function* (
   partyIds: readonly string[],
   partyPackageId: string,
-): Promise<Partial<Record<string, Party>>> {
+): Effect.fn.Return<
+  Partial<Record<string, Party>>,
+  ObjectTypeMismatchError | BcsDecodeError | SuiRpcError,
+  SuiClient
+> {
   if (partyIds.length === 0) return {};
-  const { objects } = await client.core.getObjects({
-    objectIds: [...new Set(partyIds)],
-    include: { content: true },
-  });
+  const expected = partyType(partyPackageId);
+  const contentById = yield* getObjectsContent([...new Set(partyIds)]);
   const parties: Partial<Record<string, Party>> = {};
-  for (const obj of objects) {
-    if (obj instanceof Error) continue;
-    assertPartyType(obj.objectId, obj.type, partyPackageId);
-    parties[obj.objectId] = mapParty(obj.objectId, PartyBcs.parse(obj.content));
+  for (const [objectId, { content, type }] of contentById) {
+    yield* assertObjectType(objectId, normalizeStructTag(type), expected);
+    parties[objectId] = yield* decodeParty(objectId, content, expected);
   }
   return parties;
-}
+});
 
 /** Derives a party's `PartyAdminCap` id (it is a `derived_object` off the party UID). */
 export function derivePartyAdminCapId(partyId: string, partyPackageId: string): string {
@@ -108,38 +96,33 @@ export function derivePartyAdminCapId(partyId: string, partyPackageId: string):
 // === Group membership reads ===
 
 /** Collects the ids stored in every dynamic-field key of `parentId` whose type ends with `keySuffix`. */
-async function collectKeyIds(
-  client: ClientWithCoreApi,
+function collectKeyIds(
   parentId: string,
   keySuffix: string,
   codec: { parse(bytes: Uint8Array): readonly unknown[] },
-): Promise<string[]> {
-  const ids: string[] = [];
-  let cursor: string | null | undefined;
-  do {
-    const page = await client.core.listDynamicFields({ parentId, cursor: cursor ?? undefined });
-    for (const f of page.dynamicFields) {
-      if (typeof f.name?.type === "string" && f.name.type.endsWith(keySuffix) && f.name.bcs != null) {
-        const [id] = codec.parse(keyBytes(f.name.bcs));
-        ids.push(String(id));
-      }
-    }
-    cursor = page.hasNextPage ? page.cursor : null;
-  } while (cursor);
-  return ids;
+): Effect.Effect<string[], SuiRpcError, SuiClient> {
+  return listDynamicFields(parentId).pipe(
+    Stream.filter((f) => typeof f.name?.type === "string" && f.name.type.endsWith(keySuffix) && f.name.bcs != null),
+    Stream.map((f) => {
+      const [id] = codec.parse(keyBytes(f.name!.bcs));
+      return String(id);
+    }),
+    Stream.runCollect,
+    Effect.map((chunk) => Array.from(chunk)),
+  );
 }
 
 /**
  * The group ids a party currently belongs to, read from its `MembershipKey`
  * dynamic fields (the member-side record). No indexer required.
  */
-export async function getMemberships(client: ClientWithCoreApi, partyId: string): Promise<string[]> {
-  return collectKeyIds(client, partyId, "::party::MembershipKey", MembershipKeyBcs);
+export function getMemberships(partyId: string): Effect.Effect<string[], SuiRpcError, SuiClient> {
+  return collectKeyIds(partyId, "::party::MembershipKey", MembershipKeyBcs);
 }
 
 /** The member ids invited to a group but not yet accepted (its `PendingInviteKey` fields). */
-export async function getPendingInvites(client: ClientWithCoreApi, groupId: string): Promise<string[]> {
-  return collectKeyIds(client, groupId, "::party::PendingInviteKey", PendingInviteKeyBcs);
+export function getPendingInvites(groupId: string): Effect.Effect<string[], SuiRpcError, SuiClient> {
+  return collectKeyIds(groupId, "::party::PendingInviteKey", PendingInviteKeyBcs);
 }
 
 /**
@@ -147,21 +130,21 @@ export async function getPendingInvites(client: ClientWithCoreApi, groupId: stri
  * This reads the member-side `PendingMembershipKey` inbox index, so it only
  * enumerates the target party's dynamic fields.
  */
-export async function getPendingMemberships(client: ClientWithCoreApi, partyId: string): Promise<string[]> {
-  return collectKeyIds(client, partyId, "::party::PendingMembershipKey", PendingMembershipKeyBcs);
+export function getPendingMemberships(partyId: string): Effect.Effect<string[], SuiRpcError, SuiClient> {
+  return collectKeyIds(partyId, "::party::PendingMembershipKey", PendingMembershipKeyBcs);
 }
 
 /** Whether `memberId` currently holds a membership record for `groupId`. */
-export async function isMember(
-  client: ClientWithCoreApi,
+export const isMember = Effect.fn("isMember")(function* (
   memberId: string,
   groupId: string,
   partyPackageId: string,
-): Promise<boolean> {
+): Effect.fn.Return<boolean, SuiRpcError, SuiClient> {
   const fieldId = deriveDynamicFieldID(
     memberId,
     `${partyPackageId}::party::MembershipKey`,
     MembershipKeyBcs.serialize([groupId]).toBytes(),
   );
-  return (await getObjectContent(client, fieldId)) !== null;
-}
+  const content = yield* getOptionalObjectContent(fieldId);
+  return Option.isSome(content);
+});

package/src/types.ts

@@ -1,18 +1,21 @@
 // Copyright (c) Miso Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-// Public, camelCase result types. The mappers in ./internal.ts turn the generated
-// (snake_case, Move-shaped) parse output into these.
+// Public, camelCase result types. The mapper in ./internal.ts turns the generated
+// (snake_case, Move-shaped) parse output into the plain shape `Party` decodes from.
 
-export type PartyKind = "individual" | "group";
+import { Schema } from "effect";
 
-export interface Party {
-  id: string;
-  kind: PartyKind;
+export const PartyKind = Schema.Literals(["individual", "group"]);
+export type PartyKind = typeof PartyKind.Type;
+
+export class Party extends Schema.Class<Party>("@misofm/partyos/Party")({
+  id: Schema.String,
+  kind: PartyKind,
   /** Human-readable name (not verified). */
-  name: string;
+  name: Schema.String,
   /** Member party ids — present only when `kind === "group"`. */
-  members?: string[];
+  members: Schema.optional(Schema.Array(Schema.String)),
   /** Unix ms when the party was created. */
-  createdAtMs: number;
-}
+  createdAtMs: Schema.Number,
+}) {}