@roko-app/instant-react-common 0.0.0-stage → 1.0.67-roko.1

package/src/InstantReactAbstractDatabase.tsx

@@ -0,0 +1,510 @@
+'use client';
+import {
+  // types
+  Auth,
+  Storage,
+  txInit,
+  type AuthState,
+  type User,
+  type ConnectionStatus,
+  type AppStatusState,
+  type TransactionChunk,
+  type RoomSchemaShape,
+  type InstaQLOptions,
+  type InstantConfig,
+  type PageInfoResponse,
+  InstantCoreDatabase,
+  init as core_init,
+  InstaQLLifecycleState,
+  InstaQLResponse,
+  RoomsOf,
+  InstantSchemaDef,
+  IInstantDatabase,
+  InstantError,
+  ValidQuery,
+  Streams,
+} from '@instantdb/core';
+import {
+  ReactNode,
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+  useSyncExternalStore,
+} from 'react';
+import { useQueryInternal } from './useQuery.ts';
+import {
+  type InfiniteQueryResult,
+  useInfiniteQuerySubscription,
+} from './useInfiniteQuerySubscription.ts';
+import { InstantReactRoom, rooms } from './InstantReactRoom.ts';
+
+const defaultAuthState = {
+  isLoading: true,
+  user: undefined,
+  error: undefined,
+};
+
+const defaultAppStatusState: AppStatusState = {
+  isLoading: true,
+  isReadOnly: undefined,
+};
+
+export default abstract class InstantReactAbstractDatabase<
+  // need to pull this schema out to another generic for query params, not sure why
+  Schema extends InstantSchemaDef<any, any, any>,
+  UseDates extends boolean = false,
+  Config extends InstantConfig<Schema, boolean> = InstantConfig<
+    Schema,
+    UseDates
+  >,
+  Rooms extends RoomSchemaShape = RoomsOf<Schema>,
+> implements IInstantDatabase<Schema>
+{
+  public tx = txInit<Schema>();
+
+  public auth: Auth;
+  public storage: Storage;
+  public streams: Streams;
+  public core: InstantCoreDatabase<Schema, UseDates>;
+
+  /** @deprecated use `core` instead */
+  public _core: InstantCoreDatabase<Schema, UseDates>;
+
+  static Store?: any;
+  static NetworkListener?: any;
+  static EventSourceImpl?: any;
+
+  constructor(
+    config: Omit<InstantConfig<Schema, UseDates>, 'useDateObjects'> & {
+      useDateObjects?: UseDates;
+    },
+    versions?: { [key: string]: string },
+  ) {
+    this.core = core_init<Schema, UseDates>(
+      config,
+      // @ts-expect-error because TS can't resolve subclass statics
+      config.Store || this.constructor.Store,
+      // @ts-expect-error because TS can't resolve subclass statics
+      this.constructor.NetworkListener,
+      versions,
+      // @ts-expect-error because TS can't resolve subclass statics
+      this.constructor.EventSourceImpl,
+    );
+    this._core = this.core;
+    this.auth = this.core.auth;
+    this.storage = this.core.storage;
+    this.streams = this.core.streams;
+  }
+
+  /**
+   * Returns a unique ID for a given `name`. It's stored in local storage,
+   * so you will get the same ID across sessions.
+   *
+   * This is useful for generating IDs that could identify a local device or user.
+   *
+   * @example
+   *  const deviceId = await db.getLocalId('device');
+   */
+  getLocalId = (name: string): Promise<string> => {
+    return this.core.getLocalId(name);
+  };
+
+  /**
+   * A hook that returns a unique ID for a given `name`. localIds are
+   * stored in local storage, so you will get the same ID across sessions.
+   *
+   * Initially returns `null`, and then loads the localId.
+   *
+   * @example
+   * const deviceId = db.useLocalId('device');
+   * if (!deviceId) return null; // loading
+   * console.log('Device ID:', deviceId)
+   */
+  useLocalId = (name: string): string | null => {
+    const [localId, setLocalId] = useState<string | null>(null);
+
+    useEffect(() => {
+      let mounted = true;
+      const f = async () => {
+        const id = await this.getLocalId(name);
+        if (!mounted) return;
+        setLocalId(id);
+      };
+      f();
+      return;
+    }, [name]);
+
+    return localId;
+  };
+
+  /**
+   * Obtain a handle to a room, which allows you to listen to topics and presence data
+   *
+   * If you don't provide a `type` or `id`, Instant will default to `_defaultRoomType` and `_defaultRoomId`
+   * as the room type and id, respectively.
+   *
+   * @see https://instantdb.com/docs/presence-and-topics
+   *
+   * @example
+   *  const room = db.room('chat', roomId);
+   *  const { peers } = db.rooms.usePresence(room);
+   */
+  room<RoomType extends string & keyof Rooms>(
+    type: RoomType = '_defaultRoomType' as RoomType,
+    id: string = '_defaultRoomId',
+  ) {
+    return new InstantReactRoom<Schema, Rooms, RoomType>(this.core, type, id);
+  }
+
+  /**
+   * Hooks for working with rooms
+   *
+   * @see https://instantdb.com/docs/presence-and-topics
+   *
+   * @example
+   *  const room = db.room('chat', roomId);
+   *  const { peers } = db.rooms.usePresence(room);
+   *  const publish = db.rooms.usePublishTopic(room, 'emoji');
+   *  // ...
+   */
+  rooms = rooms;
+
+  /**
+   * Use this to write data! You can create, update, delete, and link objects
+   *
+   * @see https://instantdb.com/docs/instaml
+   *
+   * @example
+   *   // Create a new object in the `goals` namespace
+   *   const goalId = id();
+   *   db.transact(db.tx.goals[goalId].update({title: "Get fit"}))
+   *
+   *   // Update the title
+   *   db.transact(db.tx.goals[goalId].update({title: "Get super fit"}))
+   *
+   *   // Delete it
+   *   db.transact(db.tx.goals[goalId].delete())
+   *
+   *   // Or create an association:
+   *   todoId = id();
+   *   db.transact([
+   *    db.tx.todos[todoId].update({ title: 'Go on a run' }),
+   *    db.tx.goals[goalId].link({todos: todoId}),
+   *  ])
+   */
+  transact = (
+    chunks: TransactionChunk<any, any> | TransactionChunk<any, any>[],
+  ) => {
+    return this.core.transact(chunks);
+  };
+
+  /**
+   * Use this to query your data!
+   *
+   * @see https://instantdb.com/docs/instaql
+   *
+   * @example
+   *   // listen to all goals
+   *   const { isLoading, error, data } = db.useQuery({ goals: {} });
+   *
+   *   // goals where the title is "Get Fit"
+   *   const { isLoading, error, data } = db.useQuery({
+   *     goals: { $: { where: { title: 'Get Fit' } } },
+   *   });
+   *
+   *   // all goals, _alongside_ their todos
+   *   const { isLoading, error, data } = db.useQuery({
+   *     goals: { todos: {} },
+   *   });
+   *
+   *   // skip if `user` is not logged in
+   *   const { isLoading, error, data } = db.useQuery(
+   *     auth.user ? { goals: {} } : null,
+   *   );
+   */
+  useQuery = <Q extends ValidQuery<Q, Schema>>(
+    query: null | Q,
+    opts?: InstaQLOptions,
+  ): InstaQLLifecycleState<Schema, Q, UseDates> => {
+    return useQueryInternal<Q, Schema, UseDates>(this.core, query, opts).state;
+  };
+
+  /**
+   * Listen for the logged in state. This is useful
+   * for deciding when to show a login screen.
+   *
+   * Check out the docs for an example `Login` component too!
+   *
+   * @see https://instantdb.com/docs/auth
+   * @example
+   *  function App() {
+   *    const { isLoading, user, error } = db.useAuth()
+   *    if (isLoading) {
+   *      return <div>Loading...</div>
+   *    }
+   *    if (error) {
+   *      return <div>Uh oh! {error.message}</div>
+   *    }
+   *    if (user) {
+   *      return <Main user={user} />
+   *    }
+   *    return <Login />
+   *  }
+   *
+   */
+  useAuth = (): AuthState => {
+    return this._useAuth();
+  };
+
+  protected _useAuth(): AuthState {
+    // We use a ref to store the result of the query.
+    // This is becuase `useSyncExternalStore` uses `Object.is`
+    // to compare the previous and next state.
+    // If we don't use a ref, the state will always be considered different, so
+    // the component will always re-render.
+    const resultCacheRef = useRef<AuthState>(
+      this.core._reactor._currentUserCached,
+    );
+
+    // Similar to `resultCacheRef`, `useSyncExternalStore` will unsubscribe
+    // if `subscribe` changes, so we use `useCallback` to memoize the function.
+    const subscribe = useCallback((cb: Function) => {
+      const unsubscribe = this.core.subscribeAuth((auth) => {
+        resultCacheRef.current = { isLoading: false, ...auth };
+        cb();
+      });
+
+      return unsubscribe;
+    }, []);
+
+    const state = useSyncExternalStore<AuthState>(
+      subscribe,
+      () => resultCacheRef.current,
+      () => defaultAuthState,
+    );
+    return state;
+  }
+
+  /**
+   * Subscribe to the currently logged in user.
+   * If the user is not logged in, this hook with throw an Error.
+   * You will want to protect any calls of this hook with a
+   * <db.SignedIn> component, or your own logic based on db.useAuth()
+   *
+   * @see https://instantdb.com/docs/auth
+   * @throws Error indicating user not signed in
+   * @example
+   *  function UserDisplay() {
+   *    const user = db.useUser()
+   *    return <div>Logged in as: {user.email}</div>
+   *  }
+   *
+   *  <db.SignedIn>
+   *    <UserDisplay />
+   *  </db.SignedIn>
+   *
+   */
+  useUser = (): User => {
+    const { user } = this.useAuth();
+    if (!user) {
+      throw new InstantError(
+        'useUser must be used within an auth-protected route',
+      );
+    }
+    return user;
+  };
+
+  /**
+   * One time query for the logged in state. This is useful
+   * for scenarios where you want to know the current auth
+   * state without subscribing to changes.
+   *
+   * @see https://instantdb.com/docs/auth
+   * @example
+   *   const user = await db.getAuth();
+   *   console.log('logged in as', user.email)
+   */
+  getAuth(): Promise<User | null> {
+    return this.core.getAuth();
+  }
+
+  /**
+   * Listen for connection status changes to Instant. Use this for things like
+   * showing connection state to users
+   *
+   * @see https://www.instantdb.com/docs/patterns#connection-status
+   * @example
+   *  function App() {
+   *    const status = db.useConnectionStatus()
+   *    const connectionState =
+   *      status === 'connecting' || status === 'opened'
+   *        ? 'authenticating'
+   *      : status === 'authenticated'
+   *        ? 'connected'
+   *      : status === 'closed'
+   *        ? 'closed'
+   *      : status === 'errored'
+   *        ? 'errored'
+   *      : 'unexpected state';
+   *
+   *    return <div>Connection state: {connectionState}</div>
+   *  }
+   */
+  useConnectionStatus = (): ConnectionStatus => {
+    const statusRef = useRef<ConnectionStatus>(
+      this.core._reactor.status as ConnectionStatus,
+    );
+
+    const subscribe = useCallback((cb: Function) => {
+      const unsubscribe = this.core.subscribeConnectionStatus((newStatus) => {
+        if (newStatus !== statusRef.current) {
+          statusRef.current = newStatus;
+          cb();
+        }
+      });
+
+      return unsubscribe;
+    }, []);
+
+    const status = useSyncExternalStore<ConnectionStatus>(
+      subscribe,
+      () => statusRef.current,
+      // For SSR, always return 'connecting' as the initial state
+      () => 'connecting',
+    );
+
+    return status;
+  };
+
+  /**
+   * Observe the app's maintenance-mode state. While read-only, reads and
+   * live queries keep working but writes are rejected.
+   *
+   * @example
+   *  function App() {
+   *    const { isLoading, isReadOnly } = db.useAppStatus()
+   *    if (isLoading) return null
+   *    if (isReadOnly) return <MaintenanceBanner />
+   *    // ...
+   *  }
+   */
+  useAppStatus = (): AppStatusState => {
+    const stateRef = useRef<AppStatusState>(this.core._reactor._appStatusState);
+
+    const subscribe = useCallback((cb: () => void) => {
+      return this.core.subscribeAppStatus((state) => {
+        if (
+          state.isLoading !== stateRef.current.isLoading ||
+          state.isReadOnly !== stateRef.current.isReadOnly
+        ) {
+          stateRef.current = state;
+          cb();
+        }
+      });
+    }, []);
+
+    const state = useSyncExternalStore<AppStatusState>(
+      subscribe,
+      () => stateRef.current,
+      () => defaultAppStatusState,
+    );
+
+    return state;
+  };
+
+  /**
+   * Use this for one-off queries.
+   * Returns local data if available, otherwise fetches from the server.
+   * Because we want to avoid stale data, this method will throw an error
+   * if the user is offline or there is no active connection to the server.
+   *
+   * @see https://instantdb.com/docs/instaql
+   *
+   * @example
+   *
+   *  const resp = await db.queryOnce({ goals: {} });
+   *  console.log(resp.data.goals)
+   */
+  queryOnce = <Q extends ValidQuery<Q, Schema>>(
+    query: Q,
+    opts?: InstaQLOptions,
+  ): Promise<{
+    data: InstaQLResponse<Schema, Q, UseDates>;
+    pageInfo: PageInfoResponse<Q>;
+  }> => {
+    return this.core.queryOnce(query, opts);
+  };
+
+  /**
+   * Subscribe to a query and incrementally load more items
+   *
+   * Only one top level namespace in the query is allowed.
+   *
+   * Changing the query or options while the subscription is active will
+   * reset the subscription and start over with new data.
+   * @example
+   * const {
+   *   data,
+   *   loadNextPage,
+   *   canLoadNextPage,
+   * } = db.useInfiniteQuery({
+   *   posts: {
+   *     $: {
+   *       limit: 20,   // Load 20 posts at a time
+   *       order: {
+   *         createdAt: 'desc',
+   *       },
+   *     },
+   *   },
+   * });
+   */
+  useInfiniteQuery = <Q extends ValidQuery<Q, Schema>>(
+    query: Q,
+    opts?: InstaQLOptions,
+  ): InfiniteQueryResult<Schema, Q, UseDates> => {
+    const result = useInfiniteQuerySubscription<Schema, Q, UseDates>({
+      core: this.core,
+      query: query,
+      opts,
+    });
+    return result;
+  };
+
+  /**
+   * Only render children if the user is signed in.
+   * @see https://instantdb.com/docs/auth
+   *
+   * @example
+   *  <db.SignedIn>
+   *    <MyComponent />
+   *  </db.SignedIn>
+   *
+   */
+  SignedIn: React.FC<{
+    children: ReactNode;
+  }> = ({ children }) => {
+    const auth = this.useAuth();
+    if (auth.isLoading || auth.error || !auth.user) return null;
+
+    return <>{children}</>;
+  };
+
+  /**
+   * Only render children if the user is signed out.
+   * @see https://instantdb.com/docs/auth
+   *
+   * @example
+   *  <db.SignedOut>
+   *    <MyComponent />
+   *  </db.SignedOut>
+   *
+   */
+  SignedOut: React.FC<{
+    children: ReactNode;
+  }> = ({ children }) => {
+    const auth = this.useAuth();
+    if (auth.isLoading || auth.error || auth.user) return null;
+    return <>{children}</>;
+  };
+}