Adam Hathcock
112 lines
3.5 KiB
TypeScript
112 lines
3.5 KiB
TypeScript
import { DefermentManager, MemoryOnlyDeferment } from '../deferment/defermentManager.js'
|
|
import {
|
|
CustomLogger,
|
|
Fetcher,
|
|
getFeatureFlag,
|
|
ObjectLoader2Flags
|
|
} from '../types/functions.js'
|
|
import { Base, ObjectAttributeMask } from '../types/types.js'
|
|
import { ObjectLoader2 } from './objectLoader2.js'
|
|
import { IndexedDatabase } from './stages/indexedDatabase.js'
|
|
import { MemoryDatabase } from './stages/memory/memoryDatabase.js'
|
|
import { MemoryDownloader } from './stages/memory/memoryDownloader.js'
|
|
import ServerDownloader from './stages/serverDownloader.js'
|
|
|
|
export interface ObjectLoader2FactoryOptions {
|
|
// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
|
|
keyRange?: { bound: Function; lowerBound: Function; upperBound: Function }
|
|
indexedDB?: IDBFactory
|
|
fetch?: Fetcher
|
|
attributeMask?: ObjectAttributeMask
|
|
useCache?: boolean
|
|
debug?: boolean
|
|
logger?: CustomLogger
|
|
}
|
|
|
|
export class ObjectLoader2Factory {
|
|
static createFromObjects(objects: Base[]): ObjectLoader2 {
|
|
const root = objects[0]
|
|
const records: Map<string, Base> = new Map<string, Base>()
|
|
objects.forEach((element) => {
|
|
records.set(element.id, element)
|
|
})
|
|
const loader = new ObjectLoader2({
|
|
rootId: root.id,
|
|
deferments: new MemoryOnlyDeferment(records),
|
|
database: new MemoryDatabase({ items: records }),
|
|
downloader: new MemoryDownloader(root.id, records)
|
|
})
|
|
return loader
|
|
}
|
|
|
|
static createFromJSON(json: string): ObjectLoader2 {
|
|
const jsonObj = JSON.parse(json) as Base[]
|
|
return this.createFromObjects(jsonObj)
|
|
}
|
|
|
|
static createFromUrl(params: {
|
|
serverUrl: string
|
|
streamId: string
|
|
objectId: string
|
|
token?: string
|
|
headers?: Headers
|
|
options?: ObjectLoader2FactoryOptions
|
|
attributeMask?: ObjectAttributeMask
|
|
}): ObjectLoader2 {
|
|
const log = ObjectLoader2Factory.getLogger(params.options?.logger)
|
|
let database
|
|
if (
|
|
params.options?.debug === true ||
|
|
getFeatureFlag(ObjectLoader2Flags.DEBUG) === 'true'
|
|
) {
|
|
this.logger('Using DEBUG mode for ObjectLoader2Factory')
|
|
}
|
|
const useCache = params.options?.useCache ?? true
|
|
const flag = getFeatureFlag(ObjectLoader2Flags.USE_CACHE)
|
|
const flagAllowsCache = flag !== 'false'
|
|
|
|
if (useCache && flagAllowsCache) {
|
|
database = new IndexedDatabase({
|
|
indexedDB: params.options?.indexedDB,
|
|
keyRange: params.options?.keyRange
|
|
})
|
|
} else {
|
|
database = new MemoryDatabase({
|
|
items: new Map<string, Base>()
|
|
})
|
|
this.logger(
|
|
'Disabled persistent caching for ObjectLoader2. Using MemoryDatabase'
|
|
)
|
|
}
|
|
const logger = log || (((): void => {}) as CustomLogger)
|
|
const loader = new ObjectLoader2({
|
|
rootId: params.objectId,
|
|
deferments: new DefermentManager(logger),
|
|
downloader: new ServerDownloader({
|
|
serverUrl: params.serverUrl,
|
|
streamId: params.streamId,
|
|
objectId: params.objectId,
|
|
token: params.token,
|
|
headers: params.headers,
|
|
fetch: params.options?.fetch,
|
|
attributeMask: params.attributeMask,
|
|
logger
|
|
}),
|
|
database,
|
|
logger
|
|
})
|
|
return loader
|
|
}
|
|
|
|
static getLogger(providedLogger?: CustomLogger): CustomLogger | undefined {
|
|
if (getFeatureFlag(ObjectLoader2Flags.DEBUG) === 'true') {
|
|
return providedLogger || this.logger
|
|
}
|
|
return providedLogger
|
|
}
|
|
|
|
static logger: CustomLogger = (m?: string, ...optionalParams: unknown[]) => {
|
|
console.log(`[debug] ${m}`, ...optionalParams)
|
|
}
|
|
}
|