@fractalshq/sync 0.1.0 → 0.1.2

package/dist/v1/react/index.mjs

@@ -0,0 +1,330 @@
+import {
+  DEFAULT_BASE_PATH,
+  SyncReactError,
+  buildDistributionTransaction,
+  commitDistributionSignature,
+  requestJSON,
+  resolveFetcher,
+  sanitizeBasePath
+} from "../../chunk-FBL2T6BA.mjs";
+import {
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-FWCSY2DS.mjs";
+
+// src/v1/react/index.tsx
+import { createContext, createElement, useCallback, useContext, useMemo, useState } from "react";
+import { useMutation, useQuery } from "@tanstack/react-query";
+var SyncContext = createContext({ basePath: DEFAULT_BASE_PATH });
+function SyncProvider({ basePath, fetcher, children }) {
+  const value = useMemo(
+    () => ({
+      basePath: sanitizeBasePath(basePath || DEFAULT_BASE_PATH),
+      fetcher
+    }),
+    [basePath, fetcher]
+  );
+  return createElement(SyncContext.Provider, { value }, children);
+}
+function useSyncClient() {
+  const requestConfig = useSyncRequestConfig();
+  return useMemo(() => {
+    const request = (path, init) => requestJSON(requestConfig, path, init);
+    return {
+      basePath: requestConfig.basePath,
+      request,
+      get: (path, init) => request(path, __spreadProps(__spreadValues({}, init), { method: "GET" })),
+      post: (path, body, init) => {
+        const finalInit = __spreadProps(__spreadValues({}, init), { method: ((init == null ? void 0 : init.method) || "POST").toUpperCase() });
+        if (body !== void 0) {
+          finalInit.body = typeof body === "string" ? body : JSON.stringify(body);
+        }
+        return request(path, finalInit);
+      }
+    };
+  }, [requestConfig]);
+}
+function useDistributions(paramsOrOptions, optionsMaybe) {
+  var _a, _b;
+  const client = useSyncClient();
+  const { params, options } = resolveDistributionsArgs(paramsOrOptions, optionsMaybe);
+  const path = buildDistributionsPath(params);
+  return useQuery(__spreadValues({
+    queryKey: ["sync", "distributions", "me", (_a = params == null ? void 0 : params.role) != null ? _a : "claimant", (_b = params == null ? void 0 : params.status) != null ? _b : "all"],
+    queryFn: () => client.get(path)
+  }, options));
+}
+function useDistribution(distributionId, options) {
+  var _a;
+  const client = useSyncClient();
+  const id = distributionId ? encodeURIComponent(distributionId) : "";
+  return useQuery(__spreadProps(__spreadValues({
+    queryKey: ["sync", "distribution", id],
+    queryFn: () => client.get(`/distributions/me/${id}`)
+  }, options), {
+    enabled: Boolean(id) && ((_a = options == null ? void 0 : options.enabled) != null ? _a : true)
+  }));
+}
+function useDistributionTransaction(options) {
+  const requestConfig = useSyncRequestConfig();
+  return useMutation(__spreadValues({
+    mutationFn: async (input) => {
+      if (!input) throw new SyncReactError(400, "distribution_input_required");
+      return buildDistributionTransaction(input, requestConfig);
+    }
+  }, options));
+}
+function useCommitDistribution(options) {
+  const requestConfig = useSyncRequestConfig();
+  return useMutation(__spreadValues({
+    mutationFn: async (input) => {
+      if (!(input == null ? void 0 : input.distributionId)) throw new SyncReactError(400, "distribution_id_required");
+      return commitDistributionSignature(input, requestConfig);
+    }
+  }, options));
+}
+function useDistributionFlow() {
+  var _a, _b;
+  const buildMutation = useDistributionTransaction();
+  const commitMutation = useCommitDistribution();
+  const [latestPayload, setLatestPayload] = useState(null);
+  const [latestInput, setLatestInput] = useState(null);
+  const build = useCallback(
+    async (input) => {
+      const payload = await buildMutation.mutateAsync(input);
+      setLatestPayload(payload);
+      setLatestInput(cloneDistributionInput(input));
+      return payload;
+    },
+    [buildMutation]
+  );
+  const doCommit = useCallback(
+    async (signer, input) => {
+      let payload = null;
+      if (input) {
+        payload = await build(input);
+      } else if (latestInput) {
+        payload = await build(latestInput);
+      } else if (latestPayload) {
+        payload = latestPayload;
+      }
+      if (!payload) {
+        throw new SyncReactError(400, "distribution_payload_missing");
+      }
+      if (!payload.distributionId) {
+        throw new SyncReactError(400, "distribution_id_required");
+      }
+      const signerInput = await signer(payload);
+      if (!signerInput || !signerInput.signature && !signerInput.transaction && !signerInput.signedTransactionBase64) {
+        throw new SyncReactError(400, "distribution_signature_required");
+      }
+      const commitPayload = __spreadProps(__spreadValues({}, signerInput), {
+        distributionId: payload.distributionId
+      });
+      if (!commitPayload.exportJson && payload.exportJson) {
+        commitPayload.exportJson = payload.exportJson;
+      }
+      const commitResult = await commitMutation.mutateAsync(commitPayload);
+      return { payload, commit: commitResult, signerInput };
+    },
+    [build, latestInput, latestPayload, commitMutation]
+  );
+  const reset = useCallback(() => {
+    setLatestPayload(null);
+    setLatestInput(null);
+    buildMutation.reset();
+    commitMutation.reset();
+  }, [buildMutation, commitMutation]);
+  const error = (_b = (_a = buildMutation.error) != null ? _a : commitMutation.error) != null ? _b : null;
+  const state = useMemo(
+    () => ({
+      latestPayload,
+      building: buildMutation.isPending,
+      committing: commitMutation.isPending,
+      error
+    }),
+    [latestPayload, buildMutation.isPending, commitMutation.isPending, error]
+  );
+  return { state, build, commit: doCommit, claim: doCommit, reset };
+}
+function useClaimableDistributions(options) {
+  const client = useSyncClient();
+  return useQuery(__spreadValues({
+    queryKey: ["sync", "claims", "me"],
+    queryFn: () => client.get("/claims/me")
+  }, options));
+}
+function useClaimHistory(options) {
+  const client = useSyncClient();
+  return useQuery(__spreadValues({
+    queryKey: ["sync", "claims", "history"],
+    queryFn: () => client.get("/claims/history")
+  }, options));
+}
+function useClaimTransaction(distributionId, options) {
+  const client = useSyncClient();
+  const id = distributionId ? encodeURIComponent(distributionId) : null;
+  return useMutation(__spreadValues({
+    mutationFn: async (input = {}) => {
+      if (!id) throw new SyncReactError(400, "distribution_id_required");
+      return client.post(`/claims/${id}/create-transaction`, input);
+    }
+  }, options));
+}
+function useCommitClaim(distributionId, options) {
+  const client = useSyncClient();
+  const id = distributionId ? encodeURIComponent(distributionId) : null;
+  return useMutation(__spreadValues({
+    mutationFn: async (input) => {
+      if (!id) throw new SyncReactError(400, "distribution_id_required");
+      if (!input || !input.signature && !input.transaction && !input.signedTransactionBase64) {
+        throw new SyncReactError(400, "transaction_or_signature_required");
+      }
+      return client.post(`/claims/${id}/commit`, input);
+    }
+  }, options));
+}
+function useClaimFlow(distributionId) {
+  var _a, _b;
+  const buildMutation = useClaimTransaction(distributionId);
+  const commitMutation = useCommitClaim(distributionId);
+  const [latestPayload, setLatestPayload] = useState(null);
+  const build = useCallback(
+    async (input) => {
+      const payload = await buildMutation.mutateAsync(input != null ? input : {});
+      setLatestPayload(payload);
+      return payload;
+    },
+    [buildMutation]
+  );
+  const claim = useCallback(
+    async (signer, input) => {
+      const payload = await build(input);
+      const signerInput = await signer(payload);
+      if (!signerInput || !signerInput.signature && !signerInput.transaction && !signerInput.signedTransactionBase64) {
+        throw new SyncReactError(400, "claim_signature_required");
+      }
+      const commit = await commitMutation.mutateAsync(signerInput);
+      return { payload, commit, signerInput };
+    },
+    [build, commitMutation]
+  );
+  const reset = useCallback(() => {
+    setLatestPayload(null);
+  }, []);
+  const state = {
+    latestPayload,
+    building: buildMutation.isPending,
+    claiming: commitMutation.isPending,
+    error: (_b = (_a = buildMutation.error) != null ? _a : commitMutation.error) != null ? _b : null
+  };
+  return { state, build, claim, reset };
+}
+function useSyncRequestConfig() {
+  const context = useContext(SyncContext);
+  const basePath = sanitizeBasePath((context == null ? void 0 : context.basePath) || DEFAULT_BASE_PATH);
+  const fetcher = resolveFetcher(context == null ? void 0 : context.fetcher);
+  return useMemo(() => ({ basePath, fetcher }), [basePath, fetcher]);
+}
+function cloneDistributionInput(input) {
+  return __spreadProps(__spreadValues({}, input), {
+    recipients: input.recipients.map((recipient) => __spreadValues({}, recipient))
+  });
+}
+function resolveDistributionsArgs(paramsOrOptions, optionsMaybe) {
+  if (isDistributionsParams(paramsOrOptions)) {
+    return { params: paramsOrOptions, options: optionsMaybe };
+  }
+  return { params: void 0, options: paramsOrOptions };
+}
+function isDistributionsParams(arg) {
+  if (!arg || typeof arg !== "object") return false;
+  return "role" in arg || "status" in arg;
+}
+function buildDistributionsPath(params) {
+  const search = new URLSearchParams();
+  if ((params == null ? void 0 : params.role) && params.role !== "claimant") {
+    search.set("role", params.role);
+  }
+  if (params == null ? void 0 : params.status) {
+    search.set("status", params.status);
+  }
+  const qs = search.toString();
+  return qs ? `/distributions/me?${qs}` : "/distributions/me";
+}
+function createRecipientRowId() {
+  return `recipient-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function hydrateRecipientRow(partial) {
+  var _a, _b;
+  return {
+    id: createRecipientRowId(),
+    address: (_a = partial == null ? void 0 : partial.address) != null ? _a : "",
+    amount: (_b = partial == null ? void 0 : partial.amount) != null ? _b : ""
+  };
+}
+function useRecipientComposer(initial = []) {
+  const [rows, setRows] = useState(() => {
+    if (initial.length === 0) return [hydrateRecipientRow()];
+    return initial.map((row) => hydrateRecipientRow(row));
+  });
+  const addRow = useCallback(() => {
+    setRows((current) => [...current, hydrateRecipientRow()]);
+  }, []);
+  const removeRow = useCallback((id) => {
+    setRows((current) => {
+      if (current.length <= 1) return [hydrateRecipientRow()];
+      return current.filter((row) => row.id !== id);
+    });
+  }, []);
+  const updateRow = useCallback((id, patch) => {
+    setRows((current) => current.map((row) => row.id === id ? __spreadValues(__spreadValues({}, row), patch) : row));
+  }, []);
+  const replaceRows = useCallback((incoming) => {
+    if (!incoming.length) {
+      setRows([hydrateRecipientRow()]);
+      return;
+    }
+    setRows(incoming.map((row) => hydrateRecipientRow(row)));
+  }, []);
+  const clearRows = useCallback(() => {
+    setRows([hydrateRecipientRow()]);
+  }, []);
+  const totals = useMemo(() => {
+    const normalized = rows.map((row) => ({
+      id: row.id,
+      address: row.address.trim(),
+      amountUi: Number(row.amount) || 0,
+      amountRaw: row.amount
+    }));
+    const totalAmountUi = normalized.reduce((sum, row) => sum + Math.max(0, row.amountUi), 0);
+    return {
+      count: rows.length,
+      totalAmountUi,
+      normalized
+    };
+  }, [rows]);
+  return {
+    state: { rows, totals },
+    addRow,
+    removeRow,
+    updateRow,
+    replaceRows,
+    clearRows
+  };
+}
+export {
+  SyncProvider,
+  useClaimFlow,
+  useClaimHistory,
+  useClaimTransaction,
+  useClaimableDistributions,
+  useCommitClaim,
+  useCommitDistribution,
+  useDistribution,
+  useDistributionFlow,
+  useDistributionTransaction,
+  useDistributions,
+  useRecipientComposer,
+  useSyncClient
+};

package/dist/v1/server/index.d.mts

@@ -0,0 +1,67 @@
+import { L as ListDistributionsRequest, g as ListDistributionsResponse, l as CreateDistributionRequest, k as DistributionTransactionPayload, o as CommitDistributionRequest, p as CommitDistributionResponse, r as BuildClaimTransactionRequest, d as ClaimTransactionResponse, t as CommitClaimRequest, u as CommitClaimResponse, v as ClaimableResponse, a as Distribution, x as ClaimHistoryResponse, H as HealthResponse } from '../../api-BX1PjpZQ.mjs';
+
+type QueryInit = string | URLSearchParams | Record<string, string | number | boolean | null | undefined>;
+type HeaderInjector = () => Promise<HeadersInit> | HeadersInit;
+interface SyncServerOptions {
+    baseURL: string;
+    getHeaders?: HeaderInjector;
+}
+declare class SyncServerClient {
+    private readonly options;
+    constructor(options: SyncServerOptions);
+    static fromRequest(req: Request, baseURL?: string): SyncServerClient;
+    static fromApiKey(apiKey: string | null, baseURL?: string): SyncServerClient;
+    private request;
+    private buildQueryString;
+    private withQuery;
+    listDistributions(params?: ListDistributionsRequest): Promise<ListDistributionsResponse>;
+    createDistribution(body: CreateDistributionRequest): Promise<DistributionTransactionPayload>;
+    createDistributionWithId(distributionId: string, body: CreateDistributionRequest): Promise<DistributionTransactionPayload>;
+    commitDistribution(distributionId: string, body: CommitDistributionRequest): Promise<CommitDistributionResponse>;
+    buildClaimTransaction(body: BuildClaimTransactionRequest): Promise<ClaimTransactionResponse>;
+    commitClaim(body: CommitClaimRequest): Promise<CommitClaimResponse>;
+    getClaimable(): Promise<ClaimableResponse>;
+    getClaimsMe(query?: QueryInit): Promise<ClaimableResponse>;
+    getDistributionsMe<T = ListDistributionsResponse>(query?: QueryInit): Promise<T>;
+    getDistributionMeById<T = Distribution>(distributionId: string): Promise<T>;
+    getClaimHistory(): Promise<ClaimHistoryResponse>;
+    health(): Promise<HealthResponse>;
+}
+
+interface ApiAuthContext {
+    ok?: boolean;
+    orgId?: string | null;
+    orgRole?: string | null;
+    subjectId?: string | null;
+    wallet?: string | null;
+    platformId?: string | null;
+    platformRole?: string | null;
+    token?: string | null;
+    me?: unknown;
+}
+interface ApiAuthRequest extends Request {
+    apiAuth?: ApiAuthContext | null;
+    wallet?: string | null;
+    nextUrl?: URL;
+}
+interface SyncRouteParams {
+    fractalsSync?: string[];
+}
+interface SyncRouteHandlerContext {
+    params?: SyncRouteParams | Promise<SyncRouteParams>;
+}
+type MaybePromise<T> = T | Promise<T>;
+interface SyncHandlerOptions {
+    baseURL?: string;
+    client?: SyncServerClient;
+    getHeadersFromRequest?: (req: ApiAuthRequest) => MaybePromise<HeadersInit>;
+    onUnauthorized?: (req: Request) => MaybePromise<Response>;
+    logger?: Pick<Console, "error" | "warn" | "info">;
+}
+
+declare function syncRouteHandler(req: ApiAuthRequest, context?: SyncRouteHandlerContext, options?: SyncHandlerOptions): Promise<Response>;
+declare function createMethodHandler(method: "GET" | "POST"): (req: ApiAuthRequest, context?: SyncRouteHandlerContext, options?: SyncHandlerOptions) => Response | Promise<Response>;
+declare const GET: (req: ApiAuthRequest, context?: SyncRouteHandlerContext, options?: SyncHandlerOptions) => Response | Promise<Response>;
+declare const POST: (req: ApiAuthRequest, context?: SyncRouteHandlerContext, options?: SyncHandlerOptions) => Response | Promise<Response>;
+
+export { type ApiAuthRequest, GET, POST, type SyncHandlerOptions, SyncServerClient, type SyncServerOptions, createMethodHandler, syncRouteHandler };

package/dist/v1/server/index.d.ts

@@ -0,0 +1,67 @@
+import { L as ListDistributionsRequest, g as ListDistributionsResponse, l as CreateDistributionRequest, k as DistributionTransactionPayload, o as CommitDistributionRequest, p as CommitDistributionResponse, r as BuildClaimTransactionRequest, d as ClaimTransactionResponse, t as CommitClaimRequest, u as CommitClaimResponse, v as ClaimableResponse, a as Distribution, x as ClaimHistoryResponse, H as HealthResponse } from '../../api-BX1PjpZQ.js';
+
+type QueryInit = string | URLSearchParams | Record<string, string | number | boolean | null | undefined>;
+type HeaderInjector = () => Promise<HeadersInit> | HeadersInit;
+interface SyncServerOptions {
+    baseURL: string;
+    getHeaders?: HeaderInjector;
+}
+declare class SyncServerClient {
+    private readonly options;
+    constructor(options: SyncServerOptions);
+    static fromRequest(req: Request, baseURL?: string): SyncServerClient;
+    static fromApiKey(apiKey: string | null, baseURL?: string): SyncServerClient;
+    private request;
+    private buildQueryString;
+    private withQuery;
+    listDistributions(params?: ListDistributionsRequest): Promise<ListDistributionsResponse>;
+    createDistribution(body: CreateDistributionRequest): Promise<DistributionTransactionPayload>;
+    createDistributionWithId(distributionId: string, body: CreateDistributionRequest): Promise<DistributionTransactionPayload>;
+    commitDistribution(distributionId: string, body: CommitDistributionRequest): Promise<CommitDistributionResponse>;
+    buildClaimTransaction(body: BuildClaimTransactionRequest): Promise<ClaimTransactionResponse>;
+    commitClaim(body: CommitClaimRequest): Promise<CommitClaimResponse>;
+    getClaimable(): Promise<ClaimableResponse>;
+    getClaimsMe(query?: QueryInit): Promise<ClaimableResponse>;
+    getDistributionsMe<T = ListDistributionsResponse>(query?: QueryInit): Promise<T>;
+    getDistributionMeById<T = Distribution>(distributionId: string): Promise<T>;
+    getClaimHistory(): Promise<ClaimHistoryResponse>;
+    health(): Promise<HealthResponse>;
+}
+
+interface ApiAuthContext {
+    ok?: boolean;
+    orgId?: string | null;
+    orgRole?: string | null;
+    subjectId?: string | null;
+    wallet?: string | null;
+    platformId?: string | null;
+    platformRole?: string | null;
+    token?: string | null;
+    me?: unknown;
+}
+interface ApiAuthRequest extends Request {
+    apiAuth?: ApiAuthContext | null;
+    wallet?: string | null;
+    nextUrl?: URL;
+}
+interface SyncRouteParams {
+    fractalsSync?: string[];
+}
+interface SyncRouteHandlerContext {
+    params?: SyncRouteParams | Promise<SyncRouteParams>;
+}
+type MaybePromise<T> = T | Promise<T>;
+interface SyncHandlerOptions {
+    baseURL?: string;
+    client?: SyncServerClient;
+    getHeadersFromRequest?: (req: ApiAuthRequest) => MaybePromise<HeadersInit>;
+    onUnauthorized?: (req: Request) => MaybePromise<Response>;
+    logger?: Pick<Console, "error" | "warn" | "info">;
+}
+
+declare function syncRouteHandler(req: ApiAuthRequest, context?: SyncRouteHandlerContext, options?: SyncHandlerOptions): Promise<Response>;
+declare function createMethodHandler(method: "GET" | "POST"): (req: ApiAuthRequest, context?: SyncRouteHandlerContext, options?: SyncHandlerOptions) => Response | Promise<Response>;
+declare const GET: (req: ApiAuthRequest, context?: SyncRouteHandlerContext, options?: SyncHandlerOptions) => Response | Promise<Response>;
+declare const POST: (req: ApiAuthRequest, context?: SyncRouteHandlerContext, options?: SyncHandlerOptions) => Response | Promise<Response>;
+
+export { type ApiAuthRequest, GET, POST, type SyncHandlerOptions, SyncServerClient, type SyncServerOptions, createMethodHandler, syncRouteHandler };