@amityco/ts-sdk 0.0.1-beta.3 → 0.0.1-beta.31

package/src/channel/events/onMemberRemoved.ts

@@ -1,37 +0,0 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-
-/**
- * ```js
- * import { onMemberRemoved } from '@amityco/ts-sdk'
- * const dispose = onMemberRemoved(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
-export const onMemberRemoved = (callback: Amity.Listener<Amity.Channel>) => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.ChannelPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.channels[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'onMemberRemoved',
-    'v3.channel.didRemoveUsers',
-    filter
-  )
-}

package/src/client/api/clearCache.ts

@@ -1,23 +0,0 @@
-import { getActiveClient } from './activeClient'
-
-/**
- * ```js
- * import { clearCache } from '@amityco/ts-sdk'
- * clearCache()
- * ```
- *
- * Resets the state of the given {@link Amity.Store} names within
- * the {@link Amity.Cache} object of a {@link Amity.Client} instance
- *
- * @param stores an array of the stores names to be wiped
- *
- * @category Client API
- */
-export const clearCache = (
-  stores: Amity.Domain[] = ['user', 'file', 'channel', 'message', 'community', 'post', 'comment']
-) => {
-  const client = getActiveClient()
-  client.log('client/api/enableCache')
-
-  stores.forEach(store => client.cache?.[store]?.erase())
-}

package/src/client/api/enableCache.ts

@@ -1,35 +0,0 @@
-import { getActiveClient } from './activeClient'
-
-import { createCache } from '~/core/cache'
-import { memoryStores } from '~/core/stores'
-
-/**
- * ```js
- * import { enableCache } from '@amityco/ts-sdk'
- * enableCache()
- * ```
- *
- * Adds a new {@link Amity.Cache} object to an {@link Amity.Client} instance
- *
- * @param stores a partial dictionary of stores to be used for caching
- *
- * @category Client API
- */
-export const enableCache = (
-  stores: Parameters<typeof createCache>[0] = memoryStores(
-    'user', 
-    'file', 
-    'channel', 
-    'message', 
-    'community', 
-    'post', 
-    'comment', 
-    'communityUsers', 
-    'channelUsers'
-  ),
-) => {
-  const client = getActiveClient()
-  client.log('client/api/enableCache')
-
-  client.cache = createCache(stores)
-}

package/src/community/api/addCommunityMembersRole.ts

@@ -1,43 +0,0 @@
-import { getActiveClient } from '~/client/api'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-
-/**
- * ```js
- * import { addCommunityMembersRole } from '@amityco/ts-sdk'
- * const updated = await addCommunityMembersRole(communityId, 'foo', ['bar'])
- * ```
- *
- * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Community}
- *
- * @param communityId The ID of the {@link Amity.Community} to perform
- * @param roleId The ID of the {@link Amity.Role} to apply
- * @param userId Array of IDs of the {@link Amity.User} to perform
- * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Community}
- *
- * @category Community API
- * @async
- */
-export const addCommunityMembersRole = async (
-  communityId: Amity.Community['communityId'],
-  roleId: Amity.Role['roleId'],
-  userIds: Amity.User['userId'][]
-) => {
-  const client = getActiveClient()
-  client.log('community/addCommunityMembersRole', communityId, roleId, userIds)
-
-  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
-    `/api/v3/communities/${communityId}/users/roles`,
-    { communityId, role: roleId, userIds }
-  )
-
-  decoratePayload(data)
-  ingestInCache(data)
-
-  const { communityUsers } = data
-  return !!communityUsers.find(
-    communityUser =>
-    communityUser.communityId === communityId && communityUser.roles.includes(roleId)
-  )
-}

package/src/community/api/removeCommunityMembersRole.ts

@@ -1,43 +0,0 @@
-import { getActiveClient } from '~/client/api'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-
-/**
- * ```js
- * import { removeCommunityMembersRole } from '@amityco/ts-sdk'
- * const updated = await removeCommunityMembersRole(communityId,  'foo', ['bar'])
- * ```
- *
- * Removes an {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Community}
- *
- * @param communityId The ID of the {@link Amity.Community} to perform
- * @param role The ID of the {@link Amity.Role} to apply
- * @param userId Array of IDs of the {@link Amity.User} to perform
- * @returns A success boolean if the {@link Amity.Role} were removed from list of {@link Amity.User} in the {@link Amity.Community}
- *
- * @category Community API
- * @async
- */
-export const removeCommunityMembersRole = async (
-  communityId: Amity.Community['communityId'],
-  roleId: Amity.Role['roleId'],
-  userIds: Amity.User['userId'][]
-) => {
-  const client = getActiveClient()
-  client.log('community/removeCommunityMembersRole', communityId, roleId, userIds)
-
-  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
-    `/api/v3/communities/${communityId}/users/roles`,
-    { data: { communityId, role: roleId, userIds } }
-  )
-
-  decoratePayload(data)
-  ingestInCache(data)
-
-  const { communityUsers } = data
-  return !!communityUsers.find(
-    communityUser =>
-    communityUser.communityId === communityId && !communityUser.roles.includes(roleId)
-  )
-}

package/src/core/cache/drop.ts

@@ -1,24 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient'
-import { getResolver } from '../model/idResolvers'
-
-/**
- * Pull objects from the cache layer
- *
- * @param name The name of the store to query
- * @param keys A collection of unique keys for the store
- * @returns The collection of objects matching the keys. Keys which don't match object will be omitted
- *
- * @category Cache
- */
-export const dropFromCache = <T extends Amity.Domain>(name: T, partial: Amity.Minimal[T] & Partial<Amity.Model[T]>) => {
-  const { cache } = getActiveClient()
-  const store = cache?.[name] as unknown as Amity.Store<Amity.Model[T]>
-
-  if (!cache || !store) return []
-
-  const modelId = getResolver(name)(partial)
-  const localId = cache.lookup[`${name}#${modelId}`]
-
-  delete cache.lookup[`${name}#${modelId}`]
-  store.erase(localId)
-}

package/src/core/cache/index.ts

@@ -1,24 +0,0 @@
-export * from './pull'
-export * from './push'
-export * from './drop'
-export * from './sync'
-export * from './ingest'
-export * from './mutate'
-export * from './merge'
-
-/**
- * Creates a cache instance. The cache instance will handle stores
- * given to it as input, and will be used as the first source of cached data
- * in the SDK.
- *
- * @param stores A partial collection of stores
- * @returns A cache instance
- *
- * @category Cache
- */
-export const createCache = (
-  stores: Partial<Amity.StoreCollection<Amity.Domain[]>>
-): Amity.Cache => {
-  const lookup: Record<string, string> = {}
-  return { lookup, ...stores }
-}

package/src/core/cache/ingest.ts

@@ -1,24 +0,0 @@
-import { pushToCache } from './push'
-
-import { storeInterests } from '../model/idResolvers'
-
-/**
- * Ingest a payload (v3) into the cache
- *
- * @param payload a "backend v3" payload object
- * @param order the order of the keys to process (in case of need)
- *
- * @category Cache
- */
-export const ingestInCache = (
-  payload: Record<string, any[]> = {},
-  order = Object.keys(payload),
-) => {
-  order
-    .forEach(key => {
-      const name = storeInterests[key]
-      if (!name) return
-
-      pushToCache(name, ...payload[key])
-    })
-}

package/src/core/cache/merge.ts

@@ -1,19 +0,0 @@
-import { getResolver } from '../model/idResolvers'
-
-import { mutateCache } from './mutate'
-
-/**
- * Apply partial mutation to objects in the cache
- *
- * @param name The name of the store to query
- * @param mutation A partial view of the object to update
- *
- * @category Cache
- */
-export const mergeInCache = <T extends Amity.Domain>(
-  name: T,
-  mutation: Amity.Minimal[T] & Partial<Amity.Model[T]>
-) => {
-  const key = getResolver(name)(mutation)
-  mutateCache(name, key, model => ({ ...model, ...mutation }))
-}

package/src/core/cache/mutate.ts

@@ -1,25 +0,0 @@
-import { pullFromCache } from './pull'
-import { pushToCache } from './push'
-
-/**
- * Apply partial mutation to objects in the cache
- *
- * @param name The name of the store to query
- * @param mutation A partial view of the object to update
- *
- * @category Cache
- */
-export const mutateCache = <T extends Amity.Domain>(
-  name: T,
-  key: string,
-  mutator: (model: Amity.Model[T]) => Amity.Model[T] | undefined
-) => {
-  const [model] = pullFromCache(name, key) ?? []
-
-  if (!model) return
-
-  const mutation = mutator(model)
-  mutation && pushToCache(name, { ...model, ...mutation })
-
-  return mutation
-}

package/src/core/cache/pull.ts

@@ -1,31 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient'
-
-/**
- * Pull objects from the cache layer
- *
- * @param name The name of the store to query
- * @param keys A collection of unique keys for the store
- * @returns The collection of objects matching the keys. Keys which don't match object will be omitted
- *
- * @category Cache
- */
-export const pullFromCache = <K extends Amity.Domain>(name: K, ...keys: string[]) => {
-  const { cache } = getActiveClient()
-  const store = cache?.[name] as unknown as Amity.Store<Amity.Model[K]>
-
-  if (!cache || !store) return
-
-  const state = store.read() ?? {}
-
-  // return all
-  if (!keys?.length)
-    return Object.values(state)
-
-  // return some
-  return keys
-    .map(key => {
-      const localId = cache.lookup[`${name}#${key}`]
-      return state[localId]
-    })
-    .filter(Boolean)
-}

package/src/core/cache/push.ts

@@ -1,41 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient'
-
-import { getResolver } from '../model/idResolvers'
-
-/**
- * Pull objects from the cache layer
- *
- * @param name The name of the store to query
- * @param models A collection of models t store
- *
- * @category Cache
- */
-export const pushToCache = <T extends Amity.Domain>(
-  name: T,
-  ...models: (Amity.Model[T])[]
-) => {
-  const { cache } = getActiveClient()
-
-  const store = cache?.[name] as unknown as Amity.Store<Amity.Model[T]>
-  if (!cache || !store) return
-
-  const filtered = models.filter(Boolean)
-  if (!filtered.length) return
-
-  const synced = Object.fromEntries(
-    filtered.map(model => {
-      const modelId = getResolver(name)(model)
-      const localId = (cache.lookup[`${name}#${modelId}`] ??= model.localId)
-
-      // WARNING: shallow immutable
-      return [localId, {
-        // @ts-ignore: syncedAt is before "...model" so it can be manually overridden
-        syncedAt: Date.now(),
-        ...model,
-        localId,
-      }]
-    })
-  )
-
-  store.write(synced)
-}

package/src/core/cache/sync.ts

@@ -1,41 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient'
-
-import { identifyModel } from '../model/identifyModel'
-
-import { dropFromCache } from './drop'
-import { pushToCache } from './push'
-
-/**
- * Sync-up local ids of objects in the cache
- *
- * @param original The object holding the localId to keep
- * @param replacement The object holding the localId to discard
- *
- * @category Cache
- */
-export const syncInCache = <T extends Amity.Domain>(
-  original: Amity.Model[T],
-  replacement: Amity.Model[T],
-) => {
-  const { cache, log } = getActiveClient()
-
-  const name = identifyModel(original) ?? identifyModel(replacement)
-
-  if (!name) {
-    log('syncInCache', 'could not identify the models', { original, replacement })
-    return
-  }
-
-  const store = cache?.[name] as unknown as Amity.Store<Amity.Model[T]>
-  if (!cache || !store) return
-
-  // remove the object from cache (it's cleaner this way)
-  dropFromCache(name, original)
-  dropFromCache(name, replacement)
-
-  // glue the localIds together
-  replacement.localId = original.localId
-
-  // put back the replacement after (again, it's cleaner this way)
-  pushToCache(name, replacement)
-}

package/src/core/model/toRecord.ts

@@ -1,11 +0,0 @@
-/**
- * converts an array looking collection to an object collection, grouped by localId
- *
- * @param array array of {@link Amity.Syncable}
- * @returns array converted to object, grouped by localId
- *
- * @hidden
- */
-export const toRecord = <T extends Amity.Syncable>(array: T[]): Record<string, T> => (
-  array.reduce((acc, item) => ({ ...acc, [item.localId]: item }), {})
-)

package/src/core/query/decorate.ts

@@ -1,64 +0,0 @@
-import { uuid } from '~/core/uuid'
-
-import { getActiveClient } from '~/client/api'
-
-import {
-  getResolver,
-  identifyModel,
-  storeInterests,
-} from '../model'
-
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param timestamp the given timestamp
- */
-export const decoratePayload = (
-  payload: Record<string, object[]>,
-  timestamp: number = Date.now(),
-  keyMapping: Record<string, Amity.Domain> = storeInterests,
-) => {
-  Object.fromEntries(
-    Object.entries(payload)
-      .map(([key, models]) => ([
-        key, decorateModels(models as any[], timestamp, keyMapping[key])
-      ]))
-  )
-}
-
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param timestamp the given timestamp
- */
-export const decorateModels = <T extends Amity.Model[Amity.Domain]>(
-  models: T[],
-  timestamp: number = Date.now(),
-  type?: Amity.Domain
-) => {
-  models.forEach(model => decorateModel(model, timestamp, type))
-}
-
-/**
- * Set the model's syncedAt property and localId
- *
- * @param model the model to decorate
- * @param syncedAt the given timestamp
- * @param type An opportunity to manually pass the type. If undefined, it will be smartly computed
- */
-export const decorateModel = <T extends Amity.Model[Amity.Domain]>(
-  model: T,
-  timestamp: number = Date.now(),
-  type = identifyModel(model)
-) => {
-  model.syncedAt ??= timestamp
-
-  const { cache } = getActiveClient()
-
-  if (type) {
-    const modelId = getResolver(type)(model)
-    model.localId = cache?.lookup[`${type}#${modelId}`] ?? uuid()
-  }
-}

package/src/core/stores/index.ts

@@ -1,2 +0,0 @@
-export * from './memory'
-export * from './persistent'

package/src/core/stores/memory.ts

@@ -1,59 +0,0 @@
-/**
- * Minimal store implementation.
- *
- * Beware, the state is mutable! it is your responsibility
- * handle the state's mutations correctly. We do so in
- * order for users with mutable/observable stacks to be able
- * to decorate the state with their favorite libraries.
- *
- * @param defaultValue the hydration state value of the store
- * @returns A store instance with an "in memory" storage strategy
- *
- * @category Storage
- * @hidden
- */
-export const memoryStore = <T extends {}>(
-  defaultValue: Record<string, T> = {},
-) => {
-  const state: Record<string, T> = defaultValue
-
-  /* default read operation is just to return the state */
-  const read: Amity.StateReader<T> = () => state
-
-  /* default write operation is just to mutate the state */
-  const write: Amity.StateWriter<T> = (payload) => {
-    Object.assign(state, payload)
-  }
-
-  /* default write operation is just to mutate the state */
-  const erase: Amity.StateEraser = (...keys) => {
-    if (!keys.length)
-      keys = Object.keys(state)
-
-    keys.forEach(key => delete state[key])
-  }
-
-  return { read, write, erase } as Amity.Store<T>
-}
-
-/**
- * ```js
- * import { memoryStores } from '@amityco/core/cache/store/volatile'
- * const stores = imemoryStores('user', 'file')
- * ```
- *
- * Builds a collection of in memory stores based on the available store names
- *
- * @param names collection of store names
- * @returns a dictionary of { storeName: storeInstance } according to the given names
- *
- * @category Storage
- */
-export const memoryStores = <
-  T extends Amity.Domain[], // https://github.com/microsoft/TypeScript/issues/44155
->(...names: T) => {
-  return names.reduce((acc, name) => {
-    const store = memoryStore<Amity.Model[typeof name]>()
-    return { ...acc, [name]: store }
-  }, {} as Amity.StoreCollection<T>)
-}

package/src/core/stores/persistent.ts

@@ -1,63 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage'
-
-import { memoryStore } from './memory'
-
-const DEFAULT_DEBOUNCE_TIME = 250
-
-/**
- * Persistent store implementation.
- *
- * @param persistentKey the name of the store in persistent storage
- * @param defaultValue the hydration state value of the store
- * @param debounceTime a delay to avoid spamming the persistent storage while writing,
- * @returns A store instance with an "persistent" storage strategy
- *
- * @category Storage
- * @hidden
- */
-export const persistentStore = async <T extends {}>(
-  persistentKey: string,
-  defaultValue: Record<string, T> = {},
-  debounceTime = DEFAULT_DEBOUNCE_TIME,
-) => {
-  let initialValue = defaultValue
-
-  const serializedBackup = await AsyncStorage.getItem(persistentKey)
-
-  if (serializedBackup) {
-    try { initialValue = JSON.parse(serializedBackup) }
-    catch (err) {}
-  }
-
-  // create a store
-  const store = memoryStore<T>(initialValue)
-
-  let timer: number
-  let job: Promise<any> | null = null
-
-  const backup = () => {
-    if (job) {
-      job.then(() => backup())
-      return
-    }
-
-    clearTimeout(timer)
-    setTimeout(async () => {
-      job = Promise.resolve()
-        .then(() => AsyncStorage.setItem(persistentKey, JSON.stringify(store.read())))
-        .then(() => job = null)
-    }, debounceTime)
-  }
-
-  const write: typeof store.write = (payload) => {
-    store.write(payload)
-    backup()
-  }
-
-  const erase: typeof store.erase = (...keys) => {
-    store.erase(...keys)
-    backup()
-  }
-
-  return { read: store.read, write, erase } as Amity.Store<T>
-}