1
0
mirror of https://github.com/laurent22/joplin.git synced 2024-12-03 08:35:29 +02:00
joplin/packages/lib/file-api-driver-memory.ts

196 lines
4.6 KiB
TypeScript
Raw Normal View History

import time from './time';
const fs = require('fs-extra');
import { basicDelta, MultiPutItem } from './file-api';
export default class FileApiDriverMemory {
private items_: any[];
private deletedItems_: any[];
2017-06-18 01:49:52 +02:00
constructor() {
2017-06-13 22:12:08 +02:00
this.items_ = [];
2017-07-18 22:03:07 +02:00
this.deletedItems_ = [];
2017-06-13 22:12:08 +02:00
}
encodeContent_(content: any) {
if (content instanceof Buffer) {
return content.toString('base64');
} else {
return Buffer.from(content).toString('base64');
}
}
public get supportsMultiPut() {
return true;
}
public get supportsAccurateTimestamp() {
return true;
}
decodeContent_(content: any) {
return Buffer.from(content, 'base64').toString('utf-8');
}
itemIndexByPath(path: string) {
2017-06-13 22:12:08 +02:00
for (let i = 0; i < this.items_.length; i++) {
if (this.items_[i].path == path) return i;
}
return -1;
}
itemByPath(path: string) {
const index = this.itemIndexByPath(path);
2017-06-13 22:12:08 +02:00
return index < 0 ? null : this.items_[index];
}
newItem(path: string, isDir = false) {
const now = time.unixMs();
2017-06-13 22:12:08 +02:00
return {
path: path,
isDir: isDir,
2017-06-19 00:06:10 +02:00
updated_time: now, // In milliseconds!!
2018-02-07 22:42:52 +02:00
// created_time: now, // In milliseconds!!
2017-06-13 22:12:08 +02:00
content: '',
};
}
stat(path: string) {
const item = this.itemByPath(path);
2017-06-18 01:49:52 +02:00
return Promise.resolve(item ? Object.assign({}, item) : null);
2017-06-13 22:12:08 +02:00
}
async setTimestamp(path: string, timestampMs: number): Promise<any> {
const item = this.itemByPath(path);
2019-09-19 23:51:18 +02:00
if (!item) return Promise.reject(new Error(`File not found: ${path}`));
2017-06-27 21:48:01 +02:00
item.updated_time = timestampMs;
2017-06-13 22:12:08 +02:00
}
async list(path: string) {
const output = [];
2017-06-13 22:12:08 +02:00
for (let i = 0; i < this.items_.length; i++) {
const item = this.items_[i];
2017-06-13 22:12:08 +02:00
if (item.path == path) continue;
2019-09-19 23:51:18 +02:00
if (item.path.indexOf(`${path}/`) === 0) {
const s = item.path.substr(path.length + 1);
2017-06-13 22:12:08 +02:00
if (s.split('/').length === 1) {
const it = Object.assign({}, item);
it.path = it.path.substr(path.length + 1);
2017-06-13 22:12:08 +02:00
output.push(it);
}
}
}
2017-06-29 20:03:16 +02:00
return Promise.resolve({
items: output,
hasMore: false,
context: null,
});
2017-06-13 22:12:08 +02:00
}
async get(path: string, options: any) {
const item = this.itemByPath(path);
2017-06-18 01:49:52 +02:00
if (!item) return Promise.resolve(null);
2019-09-19 23:51:18 +02:00
if (item.isDir) return Promise.reject(new Error(`${path} is a directory, not a file`));
let output = null;
if (options.target === 'file') {
await fs.writeFile(options.path, Buffer.from(item.content, 'base64'));
} else {
const content = this.decodeContent_(item.content);
output = Promise.resolve(content);
}
return output;
2017-06-13 22:12:08 +02:00
}
async mkdir(path: string) {
const index = this.itemIndexByPath(path);
if (index >= 0) return;
2017-06-13 22:12:08 +02:00
this.items_.push(this.newItem(path, true));
}
async put(path: string, content: any, options: any = null) {
if (!options) options = {};
if (options.source === 'file') content = await fs.readFile(options.path);
const index = this.itemIndexByPath(path);
2017-06-13 22:12:08 +02:00
if (index < 0) {
const item = this.newItem(path, false);
item.content = this.encodeContent_(content);
2017-06-13 22:12:08 +02:00
this.items_.push(item);
return item;
2017-06-13 22:12:08 +02:00
} else {
this.items_[index].content = this.encodeContent_(content);
this.items_[index].updated_time = time.unixMs();
return this.items_[index];
2017-06-13 22:12:08 +02:00
}
}
public async multiPut(items: MultiPutItem[], options: any = null) {
const output: any = {
items: {},
};
for (const item of items) {
try {
const processedItem = await this.put(`/root/${item.name}`, item.body, options);
output.items[item.name] = {
item: processedItem,
error: null,
};
} catch (error) {
output.items[item.name] = {
item: null,
error: error,
};
}
}
return output;
}
async delete(path: string) {
const index = this.itemIndexByPath(path);
2017-06-13 22:12:08 +02:00
if (index >= 0) {
const item = Object.assign({}, this.items_[index]);
2017-07-18 22:03:07 +02:00
item.isDeleted = true;
item.updated_time = time.unixMs();
this.deletedItems_.push(item);
2017-06-13 22:12:08 +02:00
this.items_.splice(index, 1);
}
}
async move(oldPath: string, newPath: string): Promise<any> {
const sourceItem = this.itemByPath(oldPath);
2019-09-19 23:51:18 +02:00
if (!sourceItem) return Promise.reject(new Error(`Path not found: ${oldPath}`));
await this.delete(newPath); // Overwrite if newPath already exists
2017-06-13 22:12:08 +02:00
sourceItem.path = newPath;
}
async format() {
2017-06-13 22:58:17 +02:00
this.items_ = [];
}
async delta(path: string, options: any = null) {
const getStatFn = async (path: string) => {
const output = this.items_.slice();
for (let i = 0; i < output.length; i++) {
const item = Object.assign({}, output[i]);
2017-07-18 22:03:07 +02:00
item.path = item.path.substr(path.length + 1);
output[i] = item;
2017-07-18 22:03:07 +02:00
}
return output;
};
2017-07-18 22:03:07 +02:00
const output = await basicDelta(path, getStatFn, options);
2017-07-18 22:03:07 +02:00
return output;
}
async clearRoot() {
this.items_ = [];
}
2017-06-13 22:12:08 +02:00
}