@sanity/sdk 0.0.0-alpha.1

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@sanity/sdk",
+  "version": "0.0.0-alpha.1",
+  "private": false,
+  "description": "Sanity SDK for Content OS",
+  "keywords": [],
+  "homepage": "https://github.com/sanity-io/sdk#readme",
+  "bugs": {
+    "url": "https://github.com/sanity-io/sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/sanity-io/sdk.git"
+  },
+  "license": "MIT",
+  "author": "Sanity <developers@sanity.io>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/_exports/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "lint-staged": {
+    "*": [
+      "prettier --write --cache --ignore-unknown"
+    ]
+  },
+  "browserslist": "extends @sanity/browserslist-config",
+  "prettier": "@sanity/prettier-config",
+  "dependencies": {
+    "@sanity/client": "^6.22.3",
+    "@types/lodash-es": "^4.17.12",
+    "lodash-es": "^4.17.21",
+    "rxjs": "^7.8.1",
+    "zustand": "^5.0.1"
+  },
+  "devDependencies": {
+    "@sanity/pkg-utils": "^6.11.14",
+    "@sanity/prettier-config": "^1.0.3",
+    "@sanity/types": "^3.65.1",
+    "@vitest/coverage-v8": "2.1.8",
+    "eslint": "^9.16.0",
+    "lint-staged": "^15.2.10",
+    "prettier": "^3.4.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8",
+    "@repo/package.config": "0.0.1"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "scripts": {
+    "build": "pkg build --strict --clean --check",
+    "clean": "rimraf dist",
+    "dev": "pkg watch",
+    "format": "prettier --write --cache --ignore-unknown .",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "ts:check": "tsc --noEmit"
+  }
+}

package/src/_exports/index.ts

@@ -0,0 +1,39 @@
+/** MAIN INSTANCE */
+// Utils
+export {createSanityInstance} from '../instance/sanityInstance'
+// Types
+export type {SanityConfig} from '../instance/sanityInstance'
+export type {InternalStores, SanityInstance, SdkIdentity} from '../instance/types'
+
+/** CLIENT */
+// Utils
+export {getClient} from '../client/getClient'
+export {getSubscribableClient} from '../client/getSubscribableClient'
+// Types
+export type {ClientOptions, ClientState, ClientStore} from '../client/store/clientStore'
+
+/** SCHEMA */
+export type {SchemaState, SchemaStore} from '../schema/schemaStore'
+
+/** DOCUMENT LIST */
+export type {
+  DocumentHandle,
+  DocumentListOptions,
+  DocumentListState,
+  DocumentListStore,
+  SortOrderingItem,
+} from '../documentList/documentListStore'
+export {createDocumentListStore} from '../documentList/documentListStore'
+
+/** AUTH */
+export type {CurrentUserSlice} from '../auth/authStore'
+export {
+  type AuthConfig,
+  type AuthProvider,
+  type AuthState,
+  type AuthStateSlice,
+  type AuthStore,
+  getAuthStore,
+  type AuthTokenSlice as PublicTokenSlice,
+} from '../auth/authStore'
+export type {CurrentUser, Role} from '@sanity/types'

package/src/auth/authStore.test.ts

@@ -0,0 +1,296 @@
+import type {CurrentUser} from '@sanity/types'
+import {beforeEach, describe, expect, type Mock, test, vi} from 'vitest'
+
+import type {SanityInstance} from '../instance/types'
+import {getAuthStore} from './authStore'
+import {getInternalAuthStore} from './getInternalAuthStore'
+
+// Mock the getInternalAuthStore module
+vi.mock('./getInternalAuthStore')
+
+describe('authStore', () => {
+  const mockCurrentUser: CurrentUser = {
+    id: 'user-123',
+    name: 'Test User',
+    email: 'test@example.com',
+    profileImage: 'https://example.com/image.jpg',
+    role: 'admin',
+    roles: [],
+  }
+
+  const mockLoggedInState = {
+    authState: {
+      type: 'logged-in' as const,
+      token: 'mock-token',
+      currentUser: mockCurrentUser,
+    },
+    handleCallback: vi.fn(),
+    logout: vi.fn(),
+    dispose: vi.fn(),
+    getLoginUrls: vi.fn(),
+  }
+
+  const mockLoggedOutState = {
+    authState: {
+      type: 'logged-out' as const,
+      isDestroyingSession: false,
+    },
+    handleCallback: vi.fn(),
+    logout: vi.fn(),
+    dispose: vi.fn(),
+    getLoginUrls: vi.fn(),
+  }
+
+  const mockInternalStore = {
+    getState: vi.fn(() => mockLoggedInState),
+    getInitialState: vi.fn(() => mockLoggedInState),
+    subscribe: vi.fn((_selector, _listener) => vi.fn()),
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    ;(getInternalAuthStore as Mock).mockReturnValue(mockInternalStore)
+  })
+
+  test('creates auth store with all required methods', () => {
+    const mockInstance = {} as SanityInstance
+    const store = getAuthStore(mockInstance)
+
+    expect(store).toHaveProperty('authState')
+    expect(store).toHaveProperty('tokenState')
+    expect(store).toHaveProperty('currentUserState')
+    expect(store).toHaveProperty('handleCallback')
+    expect(store).toHaveProperty('logout')
+    expect(store).toHaveProperty('dispose')
+    expect(store).toHaveProperty('getLoginUrls')
+  })
+
+  test('authState returns correct state when logged in', () => {
+    const mockInstance = {} as SanityInstance
+    const store = getAuthStore(mockInstance)
+
+    expect(store.authState.getState()).toBe(mockLoggedInState.authState)
+    expect(store.authState.getInitialState()).toBe(mockLoggedInState.authState)
+  })
+
+  test('tokenState returns correct token when logged in', () => {
+    const mockInstance = {} as SanityInstance
+    const store = getAuthStore(mockInstance)
+
+    expect(store.tokenState.getState()).toBe('mock-token')
+    expect(store.tokenState.getInitialState()).toBe('mock-token')
+  })
+
+  test('tokenState returns null when logged out', () => {
+    const mockInstance = {} as SanityInstance
+    mockInternalStore.getState.mockReturnValue({
+      ...mockLoggedOutState,
+      authState: mockLoggedOutState.authState,
+    } as unknown as typeof mockLoggedInState)
+
+    mockInternalStore.getInitialState.mockReturnValue({
+      ...mockLoggedOutState,
+      authState: mockLoggedOutState.authState,
+    } as unknown as typeof mockLoggedInState)
+
+    const store = getAuthStore(mockInstance)
+
+    expect(store.tokenState.getState()).toBeNull()
+    expect(store.tokenState.getInitialState()).toBeNull()
+  })
+
+  test('currentUserState returns correct user when logged in', () => {
+    const mockInstance = {} as SanityInstance
+    mockInternalStore.getState.mockReturnValue(mockLoggedInState)
+    mockInternalStore.getInitialState.mockReturnValue(mockLoggedInState)
+
+    const store = getAuthStore(mockInstance)
+
+    expect(store.currentUserState.getState()).toBe(mockCurrentUser)
+    expect(store.currentUserState.getInitialState()).toBe(mockCurrentUser)
+  })
+
+  test('currentUserState returns null when logged out', () => {
+    const mockInstance = {} as SanityInstance
+    mockInternalStore.getState.mockReturnValue({
+      ...mockLoggedOutState,
+      authState: mockLoggedOutState.authState,
+    } as unknown as typeof mockLoggedInState)
+
+    mockInternalStore.getInitialState.mockReturnValue({
+      ...mockLoggedOutState,
+      authState: mockLoggedOutState.authState,
+    } as unknown as typeof mockLoggedInState)
+
+    const store = getAuthStore(mockInstance)
+
+    expect(store.currentUserState.getState()).toBeNull()
+    expect(store.currentUserState.getInitialState()).toBeNull()
+  })
+
+  test('subscribe callbacks are properly set up', () => {
+    const mockInstance = {} as SanityInstance
+    const store = getAuthStore(mockInstance)
+    const mockListener = vi.fn()
+
+    store.authState.subscribe(mockListener)
+    store.tokenState.subscribe(mockListener)
+    store.currentUserState.subscribe(mockListener)
+
+    expect(mockInternalStore.subscribe).toHaveBeenCalledTimes(3)
+  })
+
+  test('tokenState.getInitialState returns null when initial state is logged out', () => {
+    const mockInstance = {} as SanityInstance
+    mockInternalStore.getInitialState.mockReturnValue({
+      ...mockLoggedOutState,
+      authState: mockLoggedOutState.authState,
+    } as unknown as typeof mockLoggedInState)
+
+    const store = getAuthStore(mockInstance)
+    expect(store.tokenState.getInitialState()).toBeNull()
+  })
+
+  test('currentUserState.getInitialState returns null when initial state is logged out', () => {
+    const mockInstance = {} as SanityInstance
+    mockInternalStore.getInitialState.mockReturnValue({
+      ...mockLoggedOutState,
+      authState: mockLoggedOutState.authState,
+    } as unknown as typeof mockLoggedInState)
+
+    const store = getAuthStore(mockInstance)
+
+    expect(store.currentUserState.getInitialState()).toBeNull()
+  })
+
+  test('tokenState.subscribe works correctly', () => {
+    const mockInstance = {} as SanityInstance
+    const store = getAuthStore(mockInstance)
+    const mockListener = vi.fn()
+
+    store.tokenState.subscribe(mockListener)
+
+    // Simulate a state change to 'logged-in' with a new token
+    mockInternalStore.subscribe.mock.calls[0][0](
+      {
+        authState: {type: 'logged-in', token: 'new-token', currentUser: mockCurrentUser},
+      },
+      {
+        authState: {type: 'logged-in', token: 'mock-token', currentUser: mockCurrentUser},
+      },
+    )
+
+    expect(mockListener).toHaveBeenCalledWith('new-token', 'mock-token')
+  })
+
+  test('currentUserState.subscribe works correctly', () => {
+    const mockInstance = {} as SanityInstance
+    const store = getAuthStore(mockInstance)
+    const mockListener = vi.fn()
+
+    store.currentUserState.subscribe(mockListener)
+
+    // Simulate a state change to 'logged-in' with a new user
+    mockInternalStore.subscribe.mock.calls[0][0](
+      {
+        authState: {
+          type: 'logged-in',
+          token: 'mock-token',
+          currentUser: {...mockCurrentUser, name: 'New Name'},
+        },
+      },
+      {
+        authState: {type: 'logged-in', token: 'mock-token', currentUser: mockCurrentUser},
+      },
+    )
+
+    expect(mockListener).toHaveBeenCalledWith(
+      {...mockCurrentUser, name: 'New Name'},
+      mockCurrentUser,
+    )
+  })
+
+  test('tokenState.subscribe handles logged-out state correctly', () => {
+    const mockInstance = {} as SanityInstance
+    const store = getAuthStore(mockInstance)
+    const mockListener = vi.fn()
+
+    store.tokenState.subscribe(mockListener)
+
+    // Simulate a state change to 'logged-out'
+    mockInternalStore.subscribe.mock.calls[0][0](
+      {
+        authState: {type: 'logged-out', isDestroyingSession: false},
+      },
+      {
+        authState: {type: 'logged-in', token: 'mock-token', currentUser: mockCurrentUser},
+      },
+    )
+
+    expect(mockListener).toHaveBeenCalledWith(null, 'mock-token')
+  })
+
+  test('currentUserState.subscribe handles logged-out state correctly', () => {
+    const mockInstance = {} as SanityInstance
+    const store = getAuthStore(mockInstance)
+    const mockListener = vi.fn()
+
+    store.currentUserState.subscribe(mockListener)
+
+    // Simulate a state change to 'logged-out'
+    mockInternalStore.subscribe.mock.calls[0][0](
+      {
+        authState: {type: 'logged-out', isDestroyingSession: false},
+      },
+      {
+        authState: {type: 'logged-in', token: 'mock-token', currentUser: mockCurrentUser},
+      },
+    )
+
+    expect(mockListener).toHaveBeenCalledWith(null, mockCurrentUser)
+  })
+
+  test('tokenState.subscribe handles transition from logged-out to logged-in correctly', () => {
+    const mockInstance = {} as SanityInstance
+    const store = getAuthStore(mockInstance)
+    const mockListener = vi.fn()
+
+    store.tokenState.subscribe(mockListener)
+
+    // Simulate a state change from 'logged-out' to 'logged-in'
+    mockInternalStore.subscribe.mock.calls[0][0](
+      {
+        authState: {type: 'logged-in', token: 'new-token', currentUser: mockCurrentUser},
+      },
+      {
+        authState: {type: 'logged-out', isDestroyingSession: false},
+      },
+    )
+
+    expect(mockListener).toHaveBeenCalledWith('new-token', null)
+  })
+
+  test('currentUserState.subscribe handles transition from logged-out to logged-in correctly', () => {
+    const mockInstance = {} as SanityInstance
+    const store = getAuthStore(mockInstance)
+    const mockListener = vi.fn()
+
+    store.currentUserState.subscribe(mockListener)
+
+    // Simulate a state change from 'logged-out' to 'logged-in'
+    mockInternalStore.subscribe.mock.calls[0][0](
+      {
+        authState: {
+          type: 'logged-in',
+          token: 'new-token',
+          currentUser: {...mockCurrentUser, name: 'Updated User'},
+        },
+      },
+      {
+        authState: {type: 'logged-out', isDestroyingSession: false},
+      },
+    )
+
+    expect(mockListener).toHaveBeenCalledWith({...mockCurrentUser, name: 'Updated User'}, null)
+  })
+})

package/src/auth/authStore.ts

@@ -0,0 +1,125 @@
+import type {CurrentUser} from '@sanity/types'
+
+import type {SanityInstance} from '../instance/types'
+import {getInternalAuthStore} from './getInternalAuthStore'
+import type {AuthProvider, AuthState} from './internalAuthStore'
+
+/**
+ * @public
+ */
+export interface AuthStore {
+  authState: AuthStateSlice
+  tokenState: AuthTokenSlice
+  currentUserState: CurrentUserSlice
+  handleCallback: (locationHref?: string) => Promise<string | false>
+  logout: () => Promise<void>
+  dispose: () => void
+  getLoginUrls: () => AuthProvider[] | Promise<AuthProvider[]>
+}
+
+/**
+ * Public interface for the auth store.
+ * @public
+ */
+export interface AuthStateSlice {
+  getState: () => AuthState
+  getInitialState: () => AuthState
+  subscribe: (listener: (state: AuthState, prevState: AuthState) => void) => () => void
+}
+
+/**
+ * Public interface for the token store.
+ *
+ * @public
+ */
+export interface AuthTokenSlice {
+  getState: () => string | null
+  getInitialState: () => string | null
+  subscribe: (listener: (token: string | null, prevToken: string | null) => void) => () => void
+}
+
+/**
+ * Public interface for the auth store slice that contains the current user.
+ *
+ * @public
+ */
+export interface CurrentUserSlice {
+  getState: () => CurrentUser | null
+  getInitialState: () => CurrentUser | null
+  subscribe: (
+    listener: (user: CurrentUser | null, prevUser: CurrentUser | null) => void,
+  ) => () => void
+}
+
+export type {AuthConfig, AuthProvider, AuthState} from './internalAuthStore'
+
+/**
+ * Retrieves or creates an `AuthStore` for the given `SanityInstance`.
+ *
+ * @param instance - The `SanityInstance` to get or create the `AuthStore` for.
+ * @returns The `AuthStore` associated with the given `SanityInstance`.
+ *
+ * @public
+ */
+export const getAuthStore = (instance: SanityInstance): AuthStore => {
+  const internalAuthStore = getInternalAuthStore(instance)
+
+  const authState: AuthStateSlice = {
+    getState: () => internalAuthStore.getState().authState,
+    getInitialState: () => internalAuthStore.getInitialState().authState,
+    subscribe: (listener) =>
+      internalAuthStore.subscribe((current, prev) => {
+        listener(current.authState, prev.authState)
+      }),
+  }
+
+  const tokenState: AuthTokenSlice = {
+    getState: () => {
+      const state = internalAuthStore.getState()
+      if (state.authState.type !== 'logged-in') return null
+      return state.authState.token
+    },
+    getInitialState: () => {
+      const state = internalAuthStore.getInitialState()
+      if (state.authState.type !== 'logged-in') return null
+      return state.authState.token
+    },
+    subscribe: (listener) =>
+      internalAuthStore.subscribe((state, prevState) => {
+        const token = state.authState.type === 'logged-in' ? state.authState.token : null
+        const prevToken =
+          prevState.authState.type === 'logged-in' ? prevState.authState.token : null
+        listener(token, prevToken)
+      }),
+  }
+
+  const currentUserState: CurrentUserSlice = {
+    getState: () => {
+      const state = internalAuthStore.getState()
+      if (state.authState.type !== 'logged-in') return null
+      return state.authState.currentUser
+    },
+    getInitialState: () => {
+      const state = internalAuthStore.getInitialState()
+      if (state.authState.type !== 'logged-in') return null
+      return state.authState.currentUser
+    },
+    subscribe: (listener) =>
+      internalAuthStore.subscribe((state, prevState) => {
+        const user = state.authState.type === 'logged-in' ? state.authState.currentUser : null
+        const prevUser =
+          prevState.authState.type === 'logged-in' ? prevState.authState.currentUser : null
+        listener(user, prevUser)
+      }),
+  }
+
+  return {
+    authState,
+    tokenState,
+    currentUserState,
+    handleCallback: internalAuthStore.getState().handleCallback,
+    logout: internalAuthStore.getState().logout,
+    dispose: internalAuthStore.getState().dispose,
+    getLoginUrls: internalAuthStore.getState().getLoginUrls,
+  }
+}

package/src/auth/getAuthStore.test.ts

@@ -0,0 +1,14 @@
+import {describe, expect, it} from 'vitest'
+
+import {createSanityInstance} from '../instance/sanityInstance'
+import {getInternalAuthStore} from './getInternalAuthStore'
+
+describe('getAuthStore', () => {
+  it('returns the same AuthStore instance on subsequent calls for the same instance', () => {
+    const instance = createSanityInstance({projectId: 'testProject', dataset: 'testDataset'})
+    const storeA = getInternalAuthStore(instance)
+    const storeB = getInternalAuthStore(instance)
+
+    expect(storeA).toBe(storeB)
+  })
+})

package/src/auth/getInternalAuthStore.ts

@@ -0,0 +1,20 @@
+import {getOrCreateResource} from '../instance/sanityInstance'
+import type {SanityInstance} from '../instance/types'
+import {createInternalAuthStore, type InternalAuthStore} from './internalAuthStore'
+
+/**
+ * Retrieves or creates an `AuthStore` for the given `SanityInstance`.
+ *
+ * Ensures a single `AuthStore` instance is associated with the provided instance.
+ * Creates a new store using the instance's configuration if none exists.
+ *
+ * @param instance - The `SanityInstance` to get or create the `AuthStore` for.
+ * @returns The `AuthStore` associated with the given `SanityInstance`.
+ *
+ * @public
+ */
+export const getInternalAuthStore = (instance: SanityInstance): InternalAuthStore => {
+  return getOrCreateResource(instance, 'authStore', () => {
+    return createInternalAuthStore(instance, instance.config?.auth)
+  })
+}