135 lines
4.0 KiB
TypeScript
135 lines
4.0 KiB
TypeScript
import { strict as assert } from 'assert'
|
|
import { Storage, StorageCursor, StorageSession } from '../app/storage'
|
|
|
|
export class MapCursor implements StorageCursor {
|
|
_map: Map<any, any>
|
|
_limit = 0
|
|
|
|
constructor(map: Map<any, any>) {
|
|
this._map = map
|
|
}
|
|
|
|
limit(number_: number): StorageCursor {
|
|
this._limit = number_
|
|
return this
|
|
}
|
|
|
|
sort(parameters: Record<string, unknown>): StorageCursor {
|
|
return this
|
|
}
|
|
|
|
async toArray(): Promise<any[]> {
|
|
return Promise.resolve(Array.from(this._map.values()))
|
|
}
|
|
|
|
skip(offset: number): StorageCursor {
|
|
return this
|
|
}
|
|
}
|
|
|
|
export class MapStorage extends Storage {
|
|
private readonly _mapPool
|
|
private readonly _mapPoolId
|
|
|
|
constructor(dsn: string) {
|
|
super(dsn)
|
|
this._mapPoolId = {}
|
|
this._mapPool = {}
|
|
}
|
|
|
|
async find(name: string, query: Record<string, unknown>): Promise<StorageCursor> {
|
|
if (!(name in this._mapPool)) {
|
|
return new MapCursor(new Map())
|
|
}
|
|
|
|
const map: Map<any, any> = new Map()
|
|
for (const [_, element] of this._mapPool[name]) {
|
|
nextParam: for (const [key, value] of Object.entries(query)) {
|
|
if (key in element) {
|
|
for (const symbol of ['=', '>', '<', '!']) {
|
|
if (String(value).startsWith(symbol) && eval(String(element[key] + value))) {
|
|
map.set(_, element)
|
|
break nextParam
|
|
}
|
|
}
|
|
|
|
if (element[key] == value) {
|
|
map.set(_, element)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return new MapCursor(map)
|
|
}
|
|
|
|
async count(name: string, query: Record<string, unknown>): Promise<number> {
|
|
return Promise.resolve(0)
|
|
}
|
|
|
|
async remove(collectionName: string, uniqKeyName: string, uniqKey: string): Promise<boolean> {
|
|
return Promise.resolve(true)
|
|
}
|
|
|
|
async save(name: string, idKey: string, data: Record<string, unknown>): Promise<string> {
|
|
if (!(name in this._mapPool)) {
|
|
this._mapPool[name] = new Map()
|
|
this._mapPoolId[name] = {}
|
|
}
|
|
|
|
const id = String(data[idKey])
|
|
this._mapPool[name].set(id, data)
|
|
if (!(id in this._mapPoolId[name])) {
|
|
this._mapPoolId[name][id] = Date.now()
|
|
}
|
|
|
|
return Promise.resolve(this._mapPoolId[name][id])
|
|
}
|
|
|
|
createSession(): StorageSession {
|
|
return new MapStorageSession()
|
|
}
|
|
}
|
|
|
|
class MapStorageSession extends StorageSession {
|
|
async commit(fn, options?: Record<string, unknown>): Promise<any> {
|
|
return Promise.resolve(undefined)
|
|
}
|
|
|
|
async start(options?: Record<string, unknown>): Promise<any> {
|
|
return Promise.resolve(undefined)
|
|
}
|
|
}
|
|
|
|
describe('Storage', () => {
|
|
describe('#save', () => {
|
|
it('should return inner id', async () => {
|
|
const storage = new MapStorage('')
|
|
|
|
await storage.save('items', 'id', { id: 100, value: 'one' })
|
|
const _id2 = await storage.save('items', 'id', { id: 102, value: 'two' })
|
|
|
|
const _id3 = await storage.save('items', 'id', { id: 102, value: 'two' })
|
|
assert.equal(_id2, _id3)
|
|
})
|
|
})
|
|
|
|
describe('#find', () => {
|
|
it('should return cursor', async () => {
|
|
const storage = new MapStorage('')
|
|
await storage.save('items', 'id', { id: 1, value: 'one' })
|
|
await storage.save('items', 'id', { id: 2, value: 'two' })
|
|
await storage.save('elements', 'id', { id: 1, value: 2 })
|
|
await storage.save('elements', 'id', { id: 2, value: 11 })
|
|
await storage.save('elements', 'id', { id: 3, value: 12 })
|
|
|
|
let cursor
|
|
cursor = await storage.find('items', { value: 'one' })
|
|
assert.equal((await cursor.toArray()).length, 1)
|
|
|
|
cursor = await storage.find('elements', { value: '>10' })
|
|
assert.equal((await cursor.toArray()).length, 2)
|
|
})
|
|
})
|
|
})
|