@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-beta.10

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>
-}