@misofm/platform 0.27.0 → 0.28.0

package/src/auth.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { isValidSuiAddress, normalizeSuiAddress } from "@mysten/sui/utils";
-import { Effect } from "effect";
+import { Clock, Effect } from "effect";
 import { MisoAuthError, type MisoAuthErrorCode } from "./errors.ts";
 
 export type { MisoAuthErrorCode };
@@ -58,7 +58,17 @@ export function isValidAuthorizationTarget(method: string, path: string): boolea
   );
 }
 
-/** Accept only fresh timestamps in one canonical spelling. */
+/**
+ * Accept only fresh timestamps in one canonical spelling.
+ *
+ * A plain sync utility, not `Effect`-returning, so it takes `nowMs` as an
+ * explicit parameter rather than reading `Clock` itself — a caller outside
+ * an Effect program (client-side validation, say) can still use it standalone.
+ * `Date.now()` is only this parameter's fallback default for such a caller;
+ * `parseChallenge` below (the only in-package caller, and the one Effect
+ * needs to control for testing) always resolves `nowMs` from `Clock` first
+ * and passes it explicitly (C item, misofm/sdks#35 verification).
+ */
 export function parseFreshAuthorizationIssuedAt(input: unknown, nowMs: number = Date.now()): string | null {
   if (typeof input !== "string") return null;
   const issuedAtMs = Date.parse(input);
@@ -115,7 +125,10 @@ const parseChallenge = Effect.fn("parseChallenge")(function* (
     });
   }
 
-  const nowMs = expected.nowMs ?? Date.now();
+  // `Clock`, not `Date.now()` — deterministic and `TestClock`-controllable
+  // (C item, misofm/sdks#35 verification); `expected.nowMs` still wins when
+  // a caller supplies one explicitly.
+  const nowMs = expected.nowMs ?? (yield* Clock.currentTimeMillis);
   const issuedAt = parseFreshAuthorizationIssuedAt(body.issuedAt, nowMs);
   const expiresAtMs = Date.parse(body.expiresAt);
   const canonicalAddress = normalizeSuiAddress(body.address);

package/src/catalog.ts

@@ -11,16 +11,19 @@
 // to fetch, and chooses a concurrency/rate-limit tradeoff. Those are platform
 // calls, not protocol facts.
 
-import { Effect } from "effect";
+import { Effect, Result } from "effect";
 import {
   extractTypeParams2,
-  getOwnedRecordingAdminCaps,
-  getRecordingsByIds,
-  getReleaseById,
   getWorkAddressesByShareTypes,
+  Musicos,
+  MusicosWorkNotFound,
+  type MusicosDeploymentInvalid,
+  type MusicosService,
+  type OwnedReadError,
+  type ReadError,
   type Recording,
 } from "@misofm/musicos";
-import { SuiClient, SuiGraphQL, SuiRpcError, type BcsDecodeError, type ObjectNotFoundError } from "@misofm/effect";
+import { ObjectId, Sui, SuiAddress, SuiGraphQL, type BatchItemError, type GraphQLUnavailable, type TransportError } from "@unconfirmed/sui-effect";
 import {
   getCompositionCreditsByIds,
   getRecordingCreditsByIds,
@@ -48,6 +51,25 @@ const EMPTY_RECORDING_CREDITS: RecordingCreditsView = {
   featuredArtistIds: [],
 };
 
+/**
+ * Builds `Musicos.layer({ deployment: { packageId } })`, provides it, and
+ * hands back the effect it wraps — sui-effect's "converting an existing
+ * facade" idiom (`docs/extensions.md`) applied at function granularity, so a
+ * standalone catalog read composes the sibling `@misofm/musicos` extension
+ * internally and its own requirement channel stays `Sui`, never
+ * `Sui | Musicos`. This is what a non-facade consumer (the crank service,
+ * this module itself) uses in place of a bound `Miso.protocol`.
+ */
+function withMusicos<A, E>(
+  packageId: string,
+  effect: (musicos: MusicosService) => Effect.Effect<A, E, Sui>,
+): Effect.Effect<A, E | MusicosDeploymentInvalid, Sui> {
+  return Effect.gen(function* () {
+    const musicos = yield* Musicos;
+    return yield* effect(musicos);
+  }).pipe(Effect.provide(Musicos.layer({ deployment: { packageId } })));
+}
+
 /**
  * Composition and recording credits for every track on a release, keyed by
  * recording id.
@@ -63,10 +85,10 @@ export const getReleaseTrackCredits = Effect.fn("getReleaseTrackCredits")(functi
   options: GetReleaseTrackCreditsOptions,
 ): Effect.fn.Return<
   Record<string, ReleaseTrackCredits>,
-  ObjectNotFoundError | SuiRpcError | BcsDecodeError,
-  SuiClient | SuiGraphQL
+  ReadError | MusicosDeploymentInvalid | MusicosWorkNotFound | GraphQLUnavailable | TransportError,
+  Sui | SuiGraphQL
 > {
-  const release = yield* getReleaseById(releaseId);
+  const release = yield* withMusicos(options.misoPackageId, (musicos) => musicos.getReleaseById(ObjectId.make(releaseId)));
   return yield* getTrackCreditsByRecordingIds(
     release.tracks.map((track) => track.recordingId),
     options,
@@ -81,25 +103,27 @@ export const getReleaseTrackCredits = Effect.fn("getReleaseTrackCredits")(functi
 export const getTrackCreditsByRecordingIds = Effect.fn("getTrackCreditsByRecordingIds")(function* (
   recordingIdsInput: readonly string[],
   options: GetReleaseTrackCreditsOptions,
-): Effect.fn.Return<Record<string, ReleaseTrackCredits>, SuiRpcError | BcsDecodeError, SuiClient | SuiGraphQL> {
+): Effect.fn.Return<
+  Record<string, ReleaseTrackCredits>,
+  BatchItemError | GraphQLUnavailable | MusicosWorkNotFound | TransportError,
+  Sui | SuiGraphQL
+> {
   const recordingIds = [...new Set(recordingIdsInput)];
   if (recordingIds.length === 0) return {};
 
-  const client = yield* SuiClient;
+  const sui = yield* Sui;
   const [recordingCreditsById, recordingObjects] = yield* Effect.all([
     getRecordingCreditsByIds(recordingIds, options.recordingCreditsPackageId),
-    Effect.tryPromise({
-      try: (signal) => client.core.getObjects({ objectIds: recordingIds, signal }),
-      catch: (cause) => new SuiRpcError({ operation: "getObjects", cause }),
-    }),
+    // A hard read: every id must resolve, same as the predecessor's
+    // `object instanceof Error) throw object` — a typed BatchItemError now,
+    // not a defect (sui-effect's `getObjectsOrFail`).
+    sui.getObjectsOrFail(recordingIds.map((id) => ObjectId.make(id))),
   ]);
-  const recordingReads = recordingObjects.objects.map((object, index) => {
-    const recordingId = recordingIds[index]!;
-    if (object instanceof Error) throw object;
+  const recordingReads = recordingObjects.map((object) => {
     const [, compositionShareType] = extractTypeParams2(object.type);
     return {
-      recordingId,
-      recordingCredits: recordingCreditsById[recordingId] ?? null,
+      recordingId: object.id,
+      recordingCredits: recordingCreditsById[object.id] ?? null,
       compositionShareType,
     };
   });
@@ -111,7 +135,7 @@ export const getTrackCreditsByRecordingIds = Effect.fn("getTrackCreditsByRecordi
   );
   for (const shareType of compositionShareTypes) {
     if (!addresses.compositions[shareType]) {
-      throw new Error(`Composition not found for share type: ${shareType}`);
+      return yield* Effect.fail(new MusicosWorkNotFound({ kind: "composition", shareType }));
     }
   }
   const compositionIds = [
@@ -149,25 +173,34 @@ export interface GetAdministeredRecordingsOptions {
  *
  * Three bounded stages: list the owner's `RecordingAdminCap`s, resolve every
  * share type in one aliased GraphQL query, then batch-fetch the recordings.
+ * A recording id that fails to resolve is dropped rather than failing the
+ * whole read (the predecessor's behaviour, now via `sui.getObjects`' per-item
+ * `Result` instead of a silently-dropping map).
  */
 export const getAdministeredRecordings = Effect.fn("getAdministeredRecordings")(function* (
   owner: string,
   misoPackageId: string,
   options: GetAdministeredRecordingsOptions = {},
-): Effect.fn.Return<Recording[], SuiRpcError | BcsDecodeError, SuiClient | SuiGraphQL> {
+): Effect.fn.Return<
+  Recording[],
+  MusicosDeploymentInvalid | OwnedReadError | GraphQLUnavailable | TransportError,
+  Sui | SuiGraphQL
+> {
   void options;
-  const caps = yield* getOwnedRecordingAdminCaps(owner, misoPackageId);
+  const caps = yield* withMusicos(misoPackageId, (musicos) => musicos.getOwnedRecordingAdminCaps(SuiAddress.make(owner)));
   if (caps.length === 0) return [];
   const addresses = yield* getWorkAddressesByShareTypes(
     { compositions: [], recordings: caps.map((cap) => cap.shareType) },
     misoPackageId,
   );
-  const byId = yield* getRecordingsByIds(
-    Object.values(addresses.recordings).filter((id): id is string => id !== undefined),
+  const ids = Object.values(addresses.recordings).filter((id): id is string => id !== undefined);
+  const results = yield* withMusicos(misoPackageId, (musicos) => musicos.getRecordingsByIds(ids.map((id) => ObjectId.make(id))));
+  const byId = new Map(
+    results.flatMap((result, index) => (Result.isSuccess(result) ? [[ids[index]!, result.success] as const] : [])),
   );
   return caps.flatMap((cap) => {
     const id = addresses.recordings[cap.shareType];
-    const recording = id ? byId[id] : undefined;
+    const recording = id ? byId.get(id) : undefined;
     return recording ? [recording] : [];
   });
 });