@misofm/platform 0.25.0 → 0.26.1

package/src/pressing.ts

@@ -4,15 +4,23 @@
 // Primary Record sales. `record` owns concrete Records and edition-scoped
 // Pressings; immutable `record_shop` owns per-currency Listings and payment.
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
 import {
   deriveObjectID,
   normalizeStructTag,
   normalizeSuiAddress,
   parseStructTag,
 } from "@mysten/sui/utils";
+import { Effect, Schema } from "effect";
+import {
+  assertObjectType,
+  decodeBcs,
+  getObjectsContent,
+  getOptionalObjectContent,
+  ObjectTypeMismatchError,
+  type SuiClient,
+} from "@misofm/effect";
+import type { BcsDecodeError, SuiRpcError } from "@misofm/effect";
 import type { TxThunk } from "./transactions.ts";
-import { isNotFound } from "./queries.ts";
 import { asU64, type U64Input } from "./vault.ts";
 import * as pressingContract from "./contracts/record/pressing.ts";
 import * as recordContract from "./contracts/record/record.ts";
@@ -406,54 +414,45 @@ export function purchaseRecord(p: PurchaseRecordParams): TxThunk {
   };
 }
 
-export interface PressingView {
-  id: string;
-  releaseId: string;
-  edition: number;
-  supply: number;
-  maxSupply: number | null;
-  distributors: string[];
-}
-
-export interface ListingView {
-  id: string;
-  releaseId: string;
-  pressingId: string;
-  pricing: { kind: "fixed" | "floor"; amount: string };
-  state: ListingSwitch;
-  currencyType: string;
-}
-
-export interface RecordView {
-  id: string;
-  releaseId: string;
-  pressingId: string;
-  edition: number;
-  number: number;
-  purchaseCurrency: string;
-  purchasePrice: string;
-  purchasedBy: string;
-  purchasedTimestampMs: string;
-}
-
-async function fetch(
-  client: ClientWithCoreApi,
-  objectId: string,
-): Promise<{ content: Uint8Array; type: string } | null> {
-  try {
-    const { object } = await client.core.getObject({
-      objectId,
-      include: { content: true },
-    });
-    if (!object) return null;
-    if (!object.content || !object.type)
-      throw new Error(`object ${objectId} has no BCS content or full type`);
-    return { content: object.content, type: object.type };
-  } catch (error) {
-    if (isNotFound(error)) return null;
-    throw error;
-  }
-}
+/** One permanent record-production run derived from a release. */
+export class Pressing extends Schema.Class<Pressing>("@misofm/platform/Pressing")({
+  id: Schema.String,
+  releaseId: Schema.String,
+  edition: Schema.Number,
+  supply: Schema.Number,
+  maxSupply: Schema.NullOr(Schema.Number),
+  distributors: Schema.Array(Schema.String),
+}) {}
+
+/** One permanent currency offer derived from a Pressing. */
+export class Listing extends Schema.Class<Listing>("@misofm/platform/Listing")({
+  id: Schema.String,
+  releaseId: Schema.String,
+  pressingId: Schema.String,
+  pricing: Schema.Struct({
+    kind: Schema.Literals(["fixed", "floor"]),
+    amount: Schema.String,
+  }),
+  state: Schema.Literals(["enabled", "disabled"]),
+  currencyType: Schema.String,
+}) {}
+
+/**
+ * One purchased copy of a Pressing. Named `PressingRecord`, not `Record` — the
+ * Move type is `record::Record`, but `Record` collides with TypeScript's
+ * built-in `Record<K, V>` utility type, which this codebase uses constantly.
+ */
+export class PressingRecord extends Schema.Class<PressingRecord>("@misofm/platform/PressingRecord")({
+  id: Schema.String,
+  releaseId: Schema.String,
+  pressingId: Schema.String,
+  edition: Schema.Number,
+  number: Schema.Number,
+  purchaseCurrency: Schema.String,
+  purchasePrice: Schema.String,
+  purchasedBy: Schema.String,
+  purchasedTimestampMs: Schema.String,
+}) {}
 
 function sameId(a: string, b: string): boolean {
   return normalizeSuiAddress(a) === normalizeSuiAddress(b);
@@ -464,15 +463,6 @@ function requireId(label: string, actual: string, expected: string): void {
     throw new Error(`${label} ${actual} does not match expected ${expected}`);
 }
 
-function requireExactType(type: string, expected: string, label: string): void {
-  const actual = normalizeStructTag(type);
-  const normalizedExpected = normalizeStructTag(expected);
-  if (actual !== normalizedExpected)
-    throw new Error(
-      `${label} has type ${actual}, expected ${normalizedExpected}`,
-    );
-}
-
 function requireListingCurrency(
   type: string,
   recordShopPackageId: string,
@@ -500,7 +490,7 @@ function enumKind(
   throw new Error(`unknown enum variant; expected ${names.join(" or ")}`);
 }
 
-function parsePricing(value: unknown): ListingView["pricing"] {
+function parsePricing(value: unknown): { kind: "fixed" | "floor"; amount: string } {
   if (!value || typeof value !== "object")
     throw new Error("Listing has malformed pricing");
   const v = value as { $kind?: string; Fixed?: string; Floor?: string };
@@ -511,13 +501,8 @@ function parsePricing(value: unknown): ListingView["pricing"] {
   return { kind: kind === "Fixed" ? "fixed" : "floor", amount };
 }
 
-function parsePressing(
-  pressingId: string,
-  content: Uint8Array,
-  type: string,
-  recordPackageId: string,
-): PressingView {
-  requireExactType(type, `${recordPackageId}::pressing::Pressing`, "Pressing");
+/** Raw BCS-parse -> camelCase mapper; `Schema.decodeUnknownEffect` (via `decodeBcs`) validates and constructs `Pressing`. */
+function mapPressing(pressingId: string, recordPackageId: string, content: Uint8Array): typeof Pressing.Encoded {
   const parsed = pressingContract.Pressing.parse(content);
   requireId("Pressing UID", parsed.id, pressingId);
   requireId(
@@ -531,19 +516,16 @@ function parsePressing(
     edition: parsed.edition,
     supply: parsed.supply,
     maxSupply: parsed.max_supply,
-    distributors: parsed.distributors.contents.map((item) =>
-      normalizeStructTag(item.name),
-    ),
+    distributors: parsed.distributors.contents.map((item) => normalizeStructTag(item.name)),
   };
 }
 
-function parseListing(
+function mapListing(
   listingId: string,
-  content: Uint8Array,
-  type: string,
   recordShopPackageId: string,
-): ListingView {
-  const currencyType = requireListingCurrency(type, recordShopPackageId);
+  currencyType: string,
+  content: Uint8Array,
+): typeof Listing.Encoded {
   const parsed = listingContract.Listing.parse(content);
   requireId("Listing UID", parsed.id, listingId);
   requireId(
@@ -562,13 +544,7 @@ function parseListing(
   };
 }
 
-function parseRecord(
-  recordId: string,
-  content: Uint8Array,
-  type: string,
-  recordPackageId: string,
-): RecordView {
-  requireExactType(type, `${recordPackageId}::record::Record`, "Record");
+function mapRecord(recordId: string, recordPackageId: string, content: Uint8Array): typeof PressingRecord.Encoded {
   const parsed = recordContract.Record.parse(content);
   requireId("Record UID", parsed.id, recordId);
   requireId(
@@ -589,38 +565,77 @@ function parseRecord(
   };
 }
 
-export async function getPressing(
-  client: ClientWithCoreApi,
+/** Fails with `ObjectTypeMismatchError` unless `type` is `recordShopPackageId`'s `listing::Listing<Currency>`; returns the currency type argument. */
+function assertListingType(
+  objectId: string,
+  type: string,
+  recordShopPackageId: string,
+): Effect.Effect<string, ObjectTypeMismatchError> {
+  return Effect.try({
+    try: () => requireListingCurrency(type, recordShopPackageId),
+    catch: () =>
+      new ObjectTypeMismatchError({
+        objectId,
+        expected: `${normalizeSuiAddress(recordShopPackageId)}::listing::Listing<Currency>`,
+        actual: normalizeStructTag(type),
+      }),
+  });
+}
+
+/** One permanent pressing by id, or `null` when no such Pressing exists. */
+export const getPressing = Effect.fn("getPressing")(function* (
   pressingId: string,
   recordPackageId: string,
-): Promise<PressingView | null> {
-  const got = await fetch(client, pressingId);
-  return got
-    ? parsePressing(pressingId, got.content, got.type, recordPackageId)
-    : null;
-}
+): Effect.fn.Return<Pressing | null, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
+  const found = yield* getOptionalObjectContent(pressingId);
+  if (found._tag === "None") return null;
+  const { content, type } = found.value;
+  yield* assertObjectType(
+    pressingId,
+    normalizeStructTag(type),
+    normalizeStructTag(`${recordPackageId}::pressing::Pressing`),
+  );
+  return yield* decodeBcs(
+    { parse: (bytes) => mapPressing(pressingId, recordPackageId, bytes) },
+    Pressing,
+    content,
+    { type: "Pressing", objectId: pressingId },
+  );
+});
 
-export async function getListing(
-  client: ClientWithCoreApi,
+/** One currency-specific listing by id, or `null` when no such Listing exists. */
+export const getListing = Effect.fn("getListing")(function* (
   listingId: string,
   recordShopPackageId: string,
-): Promise<ListingView | null> {
-  const got = await fetch(client, listingId);
-  return got
-    ? parseListing(listingId, got.content, got.type, recordShopPackageId)
-    : null;
-}
+): Effect.fn.Return<Listing | null, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
+  const found = yield* getOptionalObjectContent(listingId);
+  if (found._tag === "None") return null;
+  const { content, type } = found.value;
+  const currencyType = yield* assertListingType(listingId, type, recordShopPackageId);
+  return yield* decodeBcs(
+    { parse: (bytes) => mapListing(listingId, recordShopPackageId, currencyType, bytes) },
+    Listing,
+    content,
+    { type: "Listing", objectId: listingId },
+  );
+});
 
-export async function getRecord(
-  client: ClientWithCoreApi,
+/** One purchased copy by id, or `null` when no such Record exists. */
+export const getRecord = Effect.fn("getRecord")(function* (
   recordId: string,
   recordPackageId: string,
-): Promise<RecordView | null> {
-  const got = await fetch(client, recordId);
-  return got
-    ? parseRecord(recordId, got.content, got.type, recordPackageId)
-    : null;
-}
+): Effect.fn.Return<PressingRecord | null, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
+  const found = yield* getOptionalObjectContent(recordId);
+  if (found._tag === "None") return null;
+  const { content, type } = found.value;
+  yield* assertObjectType(recordId, normalizeStructTag(type), normalizeStructTag(`${recordPackageId}::record::Record`));
+  return yield* decodeBcs(
+    { parse: (bytes) => mapRecord(recordId, recordPackageId, bytes) },
+    PressingRecord,
+    content,
+    { type: "Record", objectId: recordId },
+  );
+});
 
 export interface GetSaleParams {
   releaseId: string;
@@ -630,10 +645,14 @@ export interface GetSaleParams {
   recordShopPackageId: string;
 }
 
-export async function getSale(
-  client: ClientWithCoreApi,
+/** A Pressing and its currency-specific Listing, read in one Core batch. Either half may be `null`. */
+export const getSale = Effect.fn("getSale")(function* (
   p: GetSaleParams,
-): Promise<{ pressing: PressingView | null; listing: ListingView | null }> {
+): Effect.fn.Return<
+  { pressing: Pressing | null; listing: Listing | null },
+  ObjectTypeMismatchError | BcsDecodeError | SuiRpcError,
+  SuiClient
+> {
   const { pressingId, listingId } = deriveSaleIds(
     p.releaseId,
     p.edition,
@@ -641,36 +660,35 @@ export async function getSale(
     p.recordPackageId,
     p.recordShopPackageId,
   );
-  const { objects } = await client.core.getObjects({
-    objectIds: [pressingId, listingId],
-    include: { content: true },
-  });
-  const [pressingObject, listingObject] = objects;
-  if (pressingObject instanceof Error && !isNotFound(pressingObject))
-    throw pressingObject;
-  if (listingObject instanceof Error && !isNotFound(listingObject))
-    throw listingObject;
-  const pressing =
-    !pressingObject || pressingObject instanceof Error
-      ? null
-      : parseBatchPressing(
-          pressingId,
-          pressingObject.content,
-          pressingObject.type,
-          p.recordPackageId,
-        );
-  const listing =
-    !listingObject || listingObject instanceof Error
-      ? null
-      : parseBatchListing(
-          listingId,
-          listingObject.content,
-          listingObject.type,
-          p.recordShopPackageId,
-        );
-  if (pressing)
+  const contentById = yield* getObjectsContent([pressingId, listingId]);
+
+  const pressingFound = contentById.get(pressingId);
+  let pressing: Pressing | null = null;
+  if (pressingFound) {
+    yield* assertObjectType(
+      pressingId,
+      normalizeStructTag(pressingFound.type),
+      normalizeStructTag(`${p.recordPackageId}::pressing::Pressing`),
+    );
+    pressing = yield* decodeBcs(
+      { parse: (bytes) => mapPressing(pressingId, p.recordPackageId, bytes) },
+      Pressing,
+      pressingFound.content,
+      { type: "Pressing", objectId: pressingId },
+    );
     requireId("Sale pressing release", pressing.releaseId, p.releaseId);
-  if (listing) {
+  }
+
+  const listingFound = contentById.get(listingId);
+  let listing: Listing | null = null;
+  if (listingFound) {
+    const currencyType = yield* assertListingType(listingId, listingFound.type, p.recordShopPackageId);
+    listing = yield* decodeBcs(
+      { parse: (bytes) => mapListing(listingId, p.recordShopPackageId, currencyType, bytes) },
+      Listing,
+      listingFound.content,
+      { type: "Listing", objectId: listingId },
+    );
     requireId("Sale listing release", listing.releaseId, p.releaseId);
     requireId("Sale listing pressing", listing.pressingId, pressingId);
     if (listing.currencyType !== normalizeStructTag(p.currencyType)) {
@@ -679,27 +697,6 @@ export async function getSale(
       );
     }
   }
-  return { pressing, listing };
-}
 
-function parseBatchPressing(
-  id: string,
-  content: Uint8Array | undefined,
-  type: string | undefined,
-  packageId: string,
-): PressingView {
-  if (!content || !type)
-    throw new Error(`Pressing ${id} has no BCS content or full type`);
-  return parsePressing(id, content, type, packageId);
-}
-
-function parseBatchListing(
-  id: string,
-  content: Uint8Array | undefined,
-  type: string | undefined,
-  packageId: string,
-): ListingView {
-  if (!content || !type)
-    throw new Error(`Listing ${id} has no BCS content or full type`);
-  return parseListing(id, content, type, packageId);
-}
+  return { pressing, listing };
+});

package/src/queries.ts

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Shared read plumbing for the platform reads.
-
-// `isNotFound` is the protocol SDK's — the not-found taxonomy is a property of
-// the Sui transports, not of any one package's objects, so it is defined once in
-// `@misofm/musicos` and re-exported here for the platform readers.
-export { isNotFound } from "@misofm/musicos";
+//
+// Not-found is a typed `ObjectNotFoundError` (see `@misofm/effect/errors`),
+// matched with `Effect.catchTag("ObjectNotFoundError", ...)` — there is no
+// `isNotFound` predicate to re-export anymore.
+export {};

package/src/read/artist.ts

@@ -10,8 +10,12 @@
 //
 // `roles` and `tags` are opt-in via `include`.
 
+import { Effect, Option } from "effect";
+import { getPartiesByIds, getPartyById } from "@misofm/partyos";
+import type { BcsDecodeError, ObjectNotFoundError, ObjectTypeMismatchError, SuiClient, SuiRpcError } from "@misofm/effect";
+import { getCtas, getGenres, getLinks, getProfile, getRoles, getTags } from "../party/queries.ts";
 import { resolveGenreNames } from "./genres.ts";
-import type { MisoClient } from "./client.ts";
+import type { MisoConfig } from "./config.ts";
 import type {
   ArtistProfile,
   PartyMember,
@@ -31,39 +35,40 @@ export function partyAvatarUrl(apiBaseUrl: string, partyId: string): string {
 }
 
 /**
- * An artist page, fully resolved. Throws only if the PARTY itself can't be read —
+ * An artist page, fully resolved. Fails only if the PARTY itself can't be read —
  * every extension is optional by design (a party with no profile set is a new
  * party, not a broken one), so each decoration read falls back to its empty value.
  */
-export async function getArtistProfile(
-  client: MisoClient,
+export const getArtistProfile = Effect.fn("getArtistProfile")(function* (
   partyId: string,
+  config: MisoConfig,
   options: GetArtistOptions = {},
-): Promise<ArtistProfile> {
+): Effect.fn.Return<
+  ArtistProfile,
+  ObjectNotFoundError | ObjectTypeMismatchError | BcsDecodeError | SuiRpcError,
+  SuiClient
+> {
   const include = new Set(options.include ?? []);
-  const { party } = client;
+  const party = config.party;
 
-  const [profile, ctas, genreIds, links, roles, tags, entity] =
-    await Promise.all([
-      party.getProfile(partyId).catch(() => null),
-      party.getCtas(partyId).catch(() => []),
-      party.getGenres(partyId).catch(() => [] as string[]),
-      party.getLinks(partyId).catch(() => []),
-      include.has("roles")
-        ? party.getRoles(partyId).catch(() => [] as string[])
-        : Promise.resolve(undefined),
-      include.has("tags")
-        ? party.getTags(partyId).catch(() => [] as string[])
-        : Promise.resolve(undefined),
-      party.getPartyById(partyId),
-    ]);
+  const [profileOpt, ctas, genreIds, links, roles, tags, entity] = yield* Effect.all([
+    getProfile(partyId, party.partyProfile).pipe(Effect.catch(() => Effect.succeed(Option.none()))),
+    getCtas(partyId, party.partyCta).pipe(Effect.catch(() => Effect.succeed([] as { label: string; url: string }[]))),
+    getGenres(partyId, party.partyGenre).pipe(Effect.catch(() => Effect.succeed([] as string[]))),
+    getLinks(partyId).pipe(Effect.catch(() => Effect.succeed([] as { platform: string; value: string; url: string }[]))),
+    include.has("roles")
+      ? getRoles(partyId, party.partyRoles).pipe(Effect.catch(() => Effect.succeed([] as string[])))
+      : Effect.succeed(undefined),
+    include.has("tags")
+      ? getTags(partyId, party.partyTags).pipe(Effect.catch(() => Effect.succeed([] as string[])))
+      : Effect.succeed(undefined),
+    getPartyById(partyId, config.partyos.partyos),
+  ]);
+  const profile = Option.getOrNull(profileOpt);
 
-  const [genres, members] = await Promise.all([
-    resolveGenreNames(client, genreIds),
-    resolveMembers(
-      client,
-      entity.kind === "group" ? (entity.members ?? []) : [],
-    ),
+  const [genres, members] = yield* Effect.all([
+    resolveGenreNames(genreIds),
+    resolveMembers(entity.kind === "group" ? (entity.members ?? []) : [], config),
   ]);
 
   return {
@@ -74,45 +79,45 @@ export async function getArtistProfile(
     bioShort: profile?.bioShort ?? null,
     bioLong: profile?.bioLong ?? null,
     country: profile?.country ?? null,
-    languages: profile?.languages ?? [],
+    languages: profile?.languages ? [...profile.languages] : [],
     genres,
     links: links.map((l) => ({
       platform: l.platform,
       value: l.value,
       url: l.url,
-    })),
+    })) as ArtistProfile["links"],
     ctas: ctas.map((c) => ({ label: c.label, url: c.url })),
     members,
     ...(roles !== undefined ? { roles } : {}),
     ...(tags !== undefined ? { tags } : {}),
-    avatarUrl: partyAvatarUrl(client.config.apiBaseUrl, entity.id),
+    avatarUrl: partyAvatarUrl(config.apiBaseUrl, entity.id),
   };
-}
+});
 
 /** Group members with names resolved. A member that fails to read is dropped. */
-async function resolveMembers(
-  client: MisoClient,
+const resolveMembers = Effect.fn("resolveMembers")(function* (
   memberIds: readonly string[],
-): Promise<PartyMember[]> {
+  config: MisoConfig,
+): Effect.fn.Return<PartyMember[], never, SuiClient> {
   if (memberIds.length === 0) return [];
-  const parties = await client.party
-    .getPartiesByIds([...memberIds])
-    .catch(() => ({}) as Record<string, undefined>);
+  const parties = yield* getPartiesByIds([...memberIds], config.partyos.partyos).pipe(
+    Effect.catch(() => Effect.succeed({} as Record<string, undefined>)),
+  );
   return memberIds.flatMap((id) => {
     const p = parties[id];
     return p ? [{ id, name: p.name }] : [];
   });
-}
+});
 
 /** Name + kind for many parties at once. Ids that don't resolve are omitted. */
-export async function getPartySummaries(
-  client: MisoClient,
+export const getPartySummaries = Effect.fn("getPartySummaries")(function* (
   ids: readonly string[],
-): Promise<PartySummary[]> {
+  config: MisoConfig,
+): Effect.fn.Return<PartySummary[], ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
   if (ids.length === 0) return [];
-  const parties = await client.party.getPartiesByIds([...ids]);
+  const parties = yield* getPartiesByIds([...ids], config.partyos.partyos);
   return ids.flatMap((id) => {
     const p = parties[id];
     return p ? [{ id, name: p.name, kind: p.kind }] : [];
   });
-}
+});