@oxy.so/services 1.0.0

package/src/ui/stores/assetStore.ts

@@ -0,0 +1,281 @@
+import { create } from 'zustand';
+import type { Asset, AssetUploadProgress, AssetLink } from '@oxy.so/core';
+
+interface AssetState {
+  // Asset data
+  assets: Record<string, Asset>;
+  uploadProgress: Record<string, AssetUploadProgress>;
+  
+  // Loading states
+  loading: {
+    uploading: boolean;
+    linking: boolean;
+    deleting: boolean;
+  };
+  
+  // Error states
+  errors: {
+    upload?: string;
+    link?: string;
+    delete?: string;
+  };
+  
+  // Actions
+  setAsset: (asset: Asset) => void;
+  setAssets: (assets: Asset[]) => void;
+  removeAsset: (assetId: string) => void;
+  
+  // Upload progress actions
+  setUploadProgress: (fileId: string, progress: AssetUploadProgress) => void;
+  removeUploadProgress: (fileId: string) => void;
+  
+  // Link management
+  addLink: (assetId: string, link: AssetLink) => void;
+  removeLink: (assetId: string, app: string, entityType: string, entityId: string) => void;
+  
+  // Loading states
+  setUploading: (uploading: boolean) => void;
+  setLinking: (linking: boolean) => void;
+  setDeleting: (deleting: boolean) => void;
+  
+  // Error management
+  setUploadError: (error?: string) => void;
+  setLinkError: (error?: string) => void;
+  setDeleteError: (error?: string) => void;
+  clearErrors: () => void;
+  
+  // Utility methods
+  getAssetsByApp: (app: string) => Asset[];
+  getAssetsByEntity: (app: string, entityType: string, entityId: string) => Asset[];
+  getAssetUsageCount: (assetId: string) => number;
+  isAssetLinked: (assetId: string, app: string, entityType: string, entityId: string) => boolean;
+  
+  // Reset store
+  reset: () => void;
+}
+
+const initialState = {
+  assets: {},
+  uploadProgress: {},
+  loading: {
+    uploading: false,
+    linking: false,
+    deleting: false,
+  },
+  errors: {},
+};
+
+export const useAssetStore = create<AssetState>((set, get) => ({
+    ...initialState,
+    
+    // Asset management
+    setAsset: (asset: Asset) => {
+      set((state) => ({
+        assets: {
+          ...state.assets,
+          [asset.id]: asset,
+        },
+      }));
+    },
+    
+    setAssets: (assets: Asset[]) => {
+      set((state) => {
+        const assetMap = assets.reduce((acc, asset) => {
+          acc[asset.id] = asset;
+          return acc;
+        }, {} as Record<string, Asset>);
+        
+        return {
+          assets: {
+            ...state.assets,
+            ...assetMap,
+          },
+        };
+      });
+    },
+    
+    removeAsset: (assetId: string) => {
+      set((state) => {
+        const { [assetId]: removed, ...rest } = state.assets;
+        return { assets: rest };
+      });
+    },
+    
+    // Upload progress
+    setUploadProgress: (fileId: string, progress: AssetUploadProgress) => {
+      set((state) => ({
+        uploadProgress: {
+          ...state.uploadProgress,
+          [fileId]: progress,
+        },
+      }));
+    },
+    
+    removeUploadProgress: (fileId: string) => {
+      set((state) => {
+        const { [fileId]: removed, ...rest } = state.uploadProgress;
+        return { uploadProgress: rest };
+      });
+    },
+    
+    // Link management
+    addLink: (assetId: string, link: AssetLink) => {
+      set((state) => {
+        const asset = state.assets[assetId];
+        if (!asset) return state;
+        
+        // Check if link already exists
+        const existingLink = asset.links.find(
+          (l: AssetLink) => l.app === link.app && 
+                 l.entityType === link.entityType && 
+                 l.entityId === link.entityId
+        );
+        
+        if (existingLink) return state;
+        
+        const updatedAsset = {
+          ...asset,
+          links: [...asset.links, link],
+          usageCount: asset.links.length + 1,
+        };
+        
+        return {
+          assets: {
+            ...state.assets,
+            [assetId]: updatedAsset,
+          },
+        };
+      });
+    },
+    
+    removeLink: (assetId: string, app: string, entityType: string, entityId: string) => {
+      set((state) => {
+        const asset = state.assets[assetId];
+        if (!asset) return state;
+        
+        const filteredLinks = asset.links.filter(
+          (link: AssetLink) => !(link.app === app && 
+                     link.entityType === entityType && 
+                     link.entityId === entityId)
+        );
+        
+        const updatedAsset = {
+          ...asset,
+          links: filteredLinks,
+          usageCount: filteredLinks.length,
+          status: filteredLinks.length === 0 ? 'trash' as const : asset.status,
+        };
+        
+        return {
+          assets: {
+            ...state.assets,
+            [assetId]: updatedAsset,
+          },
+        };
+      });
+    },
+    
+    // Loading states
+    setUploading: (uploading: boolean) => {
+      set((state) => ({
+        loading: { ...state.loading, uploading },
+      }));
+    },
+    
+    setLinking: (linking: boolean) => {
+      set((state) => ({
+        loading: { ...state.loading, linking },
+      }));
+    },
+    
+    setDeleting: (deleting: boolean) => {
+      set((state) => ({
+        loading: { ...state.loading, deleting },
+      }));
+    },
+    
+    // Error management
+    setUploadError: (error?: string) => {
+      set((state) => ({
+        errors: { ...state.errors, upload: error },
+      }));
+    },
+    
+    setLinkError: (error?: string) => {
+      set((state) => ({
+        errors: { ...state.errors, link: error },
+      }));
+    },
+    
+    setDeleteError: (error?: string) => {
+      set((state) => ({
+        errors: { ...state.errors, delete: error },
+      }));
+    },
+    
+    clearErrors: () => {
+      set({ errors: {} });
+    },
+    
+    // Utility methods
+    getAssetsByApp: (app: string) => {
+      const { assets } = get();
+      return Object.values(assets).filter((asset) =>
+        asset.links.some((link: AssetLink) => link.app === app)
+      );
+    },
+    
+    getAssetsByEntity: (app: string, entityType: string, entityId: string) => {
+      const { assets } = get();
+      return Object.values(assets).filter((asset) =>
+        asset.links.some(
+          (link: AssetLink) => link.app === app && 
+                   link.entityType === entityType && 
+                   link.entityId === entityId
+        )
+      );
+    },
+    
+    getAssetUsageCount: (assetId: string) => {
+      const { assets } = get();
+      const asset = assets[assetId];
+      return asset ? asset.usageCount : 0;
+    },
+    
+    isAssetLinked: (assetId: string, app: string, entityType: string, entityId: string) => {
+      const { assets } = get();
+      const asset = assets[assetId];
+      if (!asset) return false;
+      
+      return asset.links.some(
+        (link: AssetLink) => link.app === app && 
+                 link.entityType === entityType && 
+                 link.entityId === entityId
+      );
+    },
+    
+    // Reset store
+    reset: () => {
+      set(initialState);
+    },
+}));
+
+// Selector hooks for convenience
+export const useAssets = () => useAssetStore((state) => Object.values(state.assets));
+export const useAsset = (assetId: string) => useAssetStore((state) => state.assets[assetId]);
+export const useUploadProgress = () => useAssetStore((state) => state.uploadProgress);
+export const useAssetLoading = () => useAssetStore((state) => state.loading);
+export const useAssetErrors = () => useAssetStore((state) => state.errors);
+
+// Typed selectors for specific use cases
+export const useAssetsByApp = (app: string) => 
+  useAssetStore((state) => state.getAssetsByApp(app));
+
+export const useAssetsByEntity = (app: string, entityType: string, entityId: string) =>
+  useAssetStore((state) => state.getAssetsByEntity(app, entityType, entityId));
+
+export const useAssetUsageCount = (assetId: string) =>
+  useAssetStore((state) => state.getAssetUsageCount(assetId));
+
+export const useIsAssetLinked = (assetId: string, app: string, entityType: string, entityId: string) =>
+  useAssetStore((state) => state.isAssetLinked(assetId, app, entityType, entityId));

package/src/ui/stores/authStore.ts

@@ -0,0 +1,191 @@
+import { useCallback, useRef, useSyncExternalStore } from 'react';
+import type { User } from '@oxy.so/core';
+import type { OxyRuntime } from '../runtime';
+
+/**
+ * The signed-in user, as a zustand-shaped read/write surface.
+ *
+ * It used to BE a zustand store, and that made it a second owner of the
+ * session: the provider wrote `user`/`isAuthenticated` here, `SessionClient`
+ * wrote the same facts into its device state, and nothing reconciled them —
+ * when they disagreed, which one was right was not answerable. It is now a
+ * projection of the ONE `OxyRuntime` (ADR 0004): reads come off the runtime
+ * snapshot and writes go into the runtime, so there is nothing left to drift.
+ *
+ * The zustand SHAPE is kept deliberately — `useAuthStore(selector)`,
+ * `.getState()`, `.setState()`, `.subscribe()` — because a dozen call sites
+ * across this package and the Commons app read the user out of band, from
+ * mutation success handlers and cache helpers that are not inside a render.
+ * Rewriting them is Phase 8's cut, not this one's.
+ *
+ * `fetchUser` and `lastUserFetch` are GONE rather than projected: they were a
+ * five-minute profile cache with zero readers anywhere in the monorepo, and the
+ * Query cache has owned that job since long before this change.
+ */
+export interface AuthState {
+  user: User | null;
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  error: string | null;
+
+  loginSuccess: (user: User) => void;
+  loginFailure: (error: string) => void;
+  logout: () => void;
+  /** Replace the signed-in profile after a write (a rename, a new avatar). */
+  setUser: (user: User) => void;
+}
+
+/** The subset of `AuthState` a caller may push back in through `setState`. */
+export type AuthStatePatch = Partial<Pick<AuthState, 'user' | 'isLoading' | 'error'>>;
+
+let boundRuntime: OxyRuntime | null = null;
+let unbindRuntime: (() => void) | null = null;
+const listeners = new Set<() => void>();
+
+const loginSuccess = (user: User): void => {
+  boundRuntime?.setAccount(user);
+};
+
+const loginFailure = (error: string): void => {
+  boundRuntime?.batch(() => {
+    boundRuntime?.setLoading(false);
+    boundRuntime?.setError(error);
+  });
+};
+
+const logout = (): void => {
+  boundRuntime?.clearSession();
+};
+
+const setUser = (user: User): void => {
+  boundRuntime?.setAccount(user);
+};
+
+const SIGNED_OUT: AuthState = Object.freeze({
+  user: null,
+  isAuthenticated: false,
+  isLoading: false,
+  error: null,
+  loginSuccess,
+  loginFailure,
+  logout,
+  setUser,
+});
+
+let state: AuthState = SIGNED_OUT;
+
+function project(runtime: OxyRuntime | null): AuthState {
+  if (runtime === null) {
+    return SIGNED_OUT;
+  }
+  const snapshot = runtime.getSnapshot();
+  return Object.freeze({
+    user: snapshot.account,
+    isAuthenticated: snapshot.account !== null,
+    isLoading: snapshot.isLoading,
+    error: snapshot.error?.message ?? null,
+    loginSuccess,
+    loginFailure,
+    logout,
+    setUser,
+  });
+}
+
+function republish(): void {
+  const next = project(boundRuntime);
+  if (
+    next.user === state.user &&
+    next.isAuthenticated === state.isAuthenticated &&
+    next.isLoading === state.isLoading &&
+    next.error === state.error
+  ) {
+    return;
+  }
+  state = next;
+  for (const listener of [...listeners]) {
+    listener();
+  }
+}
+
+/**
+ * Point this surface at the provider's runtime. Called once by
+ * `OxyRuntimeProvider`; the returned function detaches it again on unmount.
+ *
+ * With nothing bound, reads answer signed-out and writes are dropped. That is
+ * the honest answer for the two places it happens — the SSR shim, and a unit
+ * test poking the store with no provider mounted — and it is why binding is an
+ * explicit call rather than a lazily-created default runtime, which is exactly
+ * the fabricated-forever-loading runtime ADR 0004 deleted.
+ */
+export function bindAuthStoreToRuntime(runtime: OxyRuntime): () => void {
+  unbindRuntime?.();
+  boundRuntime = runtime;
+  unbindRuntime = runtime.subscribe(republish);
+  republish();
+  return () => {
+    if (boundRuntime !== runtime) {
+      return;
+    }
+    unbindRuntime?.();
+    unbindRuntime = null;
+    boundRuntime = null;
+    republish();
+  };
+}
+
+const getState = (): AuthState => state;
+
+const setState = (patch: AuthStatePatch): void => {
+  boundRuntime?.batch(() => {
+    if (patch.isLoading !== undefined) {
+      boundRuntime?.setLoading(patch.isLoading);
+    }
+    if (patch.error !== undefined) {
+      boundRuntime?.setError(patch.error);
+    }
+    if (patch.user !== undefined) {
+      if (patch.user === null) {
+        boundRuntime?.clearSession();
+      } else {
+        boundRuntime?.setAccount(patch.user);
+      }
+    }
+  });
+};
+
+const subscribe = (listener: () => void): (() => void) => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+
+function useAuthStoreHook<T>(selector: (state: AuthState) => T): T {
+  // The selection is cached against the state object it came from, so a
+  // selector returning a fresh object cannot make `useSyncExternalStore` see a
+  // new value on every call and loop.
+  const cache = useRef<{ state: AuthState; value: T } | null>(null);
+  const getSelection = useCallback((): T => {
+    const cached = cache.current;
+    if (cached !== null && cached.state === state) {
+      return cached.value;
+    }
+    const value = selector(state);
+    cache.current = { state, value };
+    return value;
+  }, [selector]);
+  return useSyncExternalStore(subscribe, getSelection, getSelection);
+}
+
+/**
+ * Read the signed-in user. Zustand-shaped, projected from the runtime.
+ *
+ * A selector that builds an object must be wrapped in `useShallow` (as every
+ * call site here already does) — otherwise a structurally-equal result reads as
+ * a change on every publish.
+ */
+export const useAuthStore = Object.assign(useAuthStoreHook, {
+  getState,
+  setState,
+  subscribe,
+});