open document as file in editor window

Author: arturbiko

src/api/database.repository.ts

@@ -19,6 +19,6 @@ export default class DatabaseRepository {
 	public async remove(database: Database): Promise<void> {
 		const couch = await this.connection.instance();
 
-		await couch.db.destroy(database.label);
+		await couch.db.destroy(database.id!);
 	}
 }

src/api/document.repository.ts

@@ -39,12 +39,15 @@ export default class DocumentRepository {
 		};
 	}
 
-	public async get(document: Document): Promise<DocumentGetResponse> {
+	public async get(document: {
+		source: string;
+		_id: string;
+	}): Promise<DocumentGetResponse> {
 		const couch = await this.connection.instance();
 
 		const db = couch.use(document.source);
 
-		return db.get(document._id, {});
+		return await db.get(document._id, {});
 	}
 
 	public async remove(document: Document): Promise<void> {

src/controller/document.controller.ts

@@ -53,15 +53,15 @@ export default class DocumentController {
 
 	public async openDocument(document: Document): Promise<void> {
 		try {
-			const data = await this.documentStore.get(document);
-
 			this.documentProvider.refresh(this.documentView);
 
-			document.setRev(data._rev);
-			document.setContent(JSON.stringify(data, null, '\t'));
-
 			// open the document in a new editor
-			vscode.workspace.openTextDocument(document.uri);
+			const doc = await vscode.workspace.openTextDocument(document.uri);
+
+			// set json language mode
+			await vscode.languages.setTextDocumentLanguage(doc, 'json');
+
+			vscode.window.showTextDocument(doc);
 		} catch (error) {
 			vscode.window.showErrorMessage('Document was removed.');
 

src/core/document.store.ts

@@ -7,6 +7,8 @@ import CouchItem from '../provider/couch.item';
 import { DocumentGetResponse } from 'nano';
 
 export default class DocumentStore extends DataStore<CouchItem> {
+	public active?: DocumentGetResponse;
+
 	private total = 0;
 
 	constructor(private readonly documentRepository: DocumentRepository) {
@@ -29,8 +31,31 @@ export default class DocumentStore extends DataStore<CouchItem> {
 		return data;
 	}
 
-	public async get(document: Document): Promise<DocumentGetResponse> {
-		return await this.documentRepository.get(document);
+	public async get(document: {
+		source: string;
+		_id: string;
+	}): Promise<Document> {
+		const data = await this.documentRepository.get(document);
+
+		let doc = this.data.find((d) => (d as Document)._id! === document._id);
+		if (!doc) {
+			doc = new Document(
+				{
+					id: data._id,
+					value: {
+						rev: data._rev,
+					},
+				},
+				document.source
+			);
+
+			this.data.push(doc);
+		}
+
+		(doc as Document).mtime = Date.now();
+		(doc as Document).setContent(JSON.stringify(data, null, '\t'));
+
+		return doc as Document;
 	}
 
 	public findByURI(uri: vscode.Uri): Document | undefined {

src/provider/couch.collection.ts

@@ -72,7 +72,7 @@ export class Document extends CouchItem implements vscode.FileStat {
 
 		this.contextValue = 'document';
 
-		this.ctime = 0;
+		this.ctime = Date.now();
 		this.mtime = 0;
 	}
 

src/provider/couch.editor.provider.ts

@@ -1,69 +1,102 @@
 import * as vscode from 'vscode';
+import DocumentStore from '../core/document.store';
+import { TextEncoder } from 'util';
+import { Document } from './couch.collection';
 
 export class CouchFileSystemProvider implements vscode.FileSystemProvider {
 	public static scheme = 'couchdb';
 
 	onDidChangeFile: vscode.Event<vscode.FileChangeEvent[]>;
 
-	constructor() {
+	constructor(private readonly documentStore: DocumentStore) {
 		this.onDidChangeFile = new vscode.EventEmitter<
 			vscode.FileChangeEvent[]
 		>().event;
 	}
 
-	watch(
+	public watch(
 		uri: vscode.Uri,
 		options: { readonly recursive: boolean; readonly excludes: readonly string[] }
 	): vscode.Disposable {
-		throw new Error('Method not implemented.');
+		console.log('watch', uri, options);
+
+		return new vscode.Disposable(() => {});
 	}
 
-	stat(uri: vscode.Uri): vscode.FileStat | Thenable<vscode.FileStat> {
-		throw new Error('Method not implemented.');
+	public stat(uri: vscode.Uri): vscode.FileStat {
+		const doc = this.documentStore.findByURI(uri);
+
+		return {
+			type: vscode.FileType.File,
+			ctime: (doc as Document).ctime,
+			mtime: (doc as Document).mtime,
+			size: new TextEncoder().encode((doc as Document).content || '').length,
+		};
 	}
 
-	readDirectory(
+	public readDirectory(
 		uri: vscode.Uri
 	): [string, vscode.FileType][] | Thenable<[string, vscode.FileType][]> {
-		throw new Error('Method not implemented.');
+		console.log('readDirectory', uri);
+
+		return Promise.reject();
 	}
 
-	createDirectory(uri: vscode.Uri): void | Thenable<void> {
-		throw new Error('Method not implemented.');
+	public createDirectory(uri: vscode.Uri): void | Thenable<void> {
+		console.log('createDirectory', uri);
+
+		return Promise.reject();
 	}
 
-	readFile(uri: vscode.Uri): Uint8Array | Thenable<Uint8Array> {
-		throw new Error('Method not implemented.');
+	public async readFile(uri: vscode.Uri): Promise<Uint8Array> {
+		const document = await this.documentStore.get({
+			source: uri.authority,
+			_id: uri.path.slice(1),
+		});
+
+		if (!document) {
+			throw new Error('Document not found');
+		}
+
+		return new TextEncoder().encode(document.content);
 	}
 
-	writeFile(
+	public writeFile(
 		uri: vscode.Uri,
 		content: Uint8Array,
 		options: { readonly create: boolean; readonly overwrite: boolean }
 	): void | Thenable<void> {
-		throw new Error('Method not implemented.');
+		console.log('writeFile', uri, content, options);
+
+		return Promise.reject();
 	}
 
-	delete(
+	public delete(
 		uri: vscode.Uri,
 		options: { readonly recursive: boolean }
 	): void | Thenable<void> {
-		throw new Error('Method not implemented.');
+		console.log('delete', uri, options);
+
+		return Promise.reject();
 	}
 
-	rename(
+	public rename(
 		oldUri: vscode.Uri,
 		newUri: vscode.Uri,
 		options: { readonly overwrite: boolean }
 	): void | Thenable<void> {
-		throw new Error('Method not implemented.');
+		console.log('rename', oldUri, newUri, options);
+
+		return Promise.reject();
 	}
 
-	copy?(
+	public copy?(
 		source: vscode.Uri,
 		destination: vscode.Uri,
 		options: { readonly overwrite: boolean }
 	): void | Thenable<void> {
-		throw new Error('Method not implemented.');
+		console.log('copy', source, destination, options);
+
+		return Promise.reject();
 	}
 }

src/provider/filesystem.provider.ts

@@ -1,11 +1,15 @@
 import * as vscode from 'vscode';
 import { CouchFileSystemProvider } from '../provider/filesystem.provider';
+import DocumentStore from '../core/document.store';
 
 export default class EditorService {
 	private provider: CouchFileSystemProvider;
 
-	constructor(private readonly context: vscode.ExtensionContext) {
-		this.provider = new CouchFileSystemProvider();
+	constructor(
+		private readonly context: vscode.ExtensionContext,
+		private readonly documentStore: DocumentStore
+	) {
+		this.provider = new CouchFileSystemProvider(documentStore);
 
 		const providerRegistration = vscode.Disposable.from(
 			vscode.workspace.registerFileSystemProvider(